Node.js与MongoDB构建后端评论系统实战指南

node -v

console.log('Hello World');

const express = require('express');
const app = express();
// GET请求到根目录
app.get('/', (req, res) => {
  res.send('欢迎来到首页！');
});
// POST请求到根目录
app.post('/', (req, res) => {
  res.send('收到POST请求！');
});
// PUT请求到用户信息
app.put('/user', (req, res) => {
  res.send('更新用户信息！');
});
// DELETE请求到指定用户
app.delete('/user', (req, res) => {
  res.send('删除用户成功！');
});
const PORT = 3000;
app.listen(PORT, () => {
  console.log(`应用正在监听端口：${PORT}`);
});

// 一个简单的中间件函数
function logger(req, res, next) {
  console.log('请求已收到：', req.method, req.url);
  next(); // 传递给下一个中间件或路由处理器
}
// 应用中间件
app.use(logger); // 应用到所有请求
// 或者指定特定路由使用中间件
app.get('/user', logger, (req, res) => {
  res.send('用户信息请求已处理');
});

const cors = require('cors');
const app = express();
app.use(cors()); // 启用所有域的CORS支持
// 或者更精细的配置
app.use(cors({
  origin: 'http://example.com', // 允许来自此域的请求
  methods: ['GET', 'POST'], // 允许的HTTP方法
  allowedHeaders: ['Content-Type', 'Authorization'], // 允许的HTTP请求头
  credentials: true // 允许发送cookie
}));
// RESTful API路由和处理逻辑
// ...

app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).send('发生错误！');
});
// 或者，使用自定义错误处理来处理特定类型的错误
app.get('/user', (req, res) => {
  // 模拟错误
  throw new Error('获取用户信息失败！');
});
app.use((err, req, res, next) => {
  if (err.message === '获取用户信息失败！') {
    res.status(404).send('用户未找到');
  } else {
    res.status(500).send('服务器错误');
  }
});

const morgan = require('morgan');
app.use(morgan('dev')); // 使用'dev'格式记录请求

use myDatabase // 切换到myDatabase数据库，如果不存在则创建
// 删除数据库
db.dropDatabase();

// 创建集合
db.createCollection("users")
// 删除集合
db.users.drop();

// 查询所有文档
db.users.find()
// 指定查询条件
db.users.find({ age: { $gte: 18 } })
// 排序查询结果
db.users.find().sort({ age: -1 })

// 更新单个文档
db.users.updateOne({ _id: 1 }, { $set: { age: 20 } })
// 更新多个文档
db.users.updateMany({}, { $inc: { age: 1 } })

// 创建索引
db.users.createIndex({ username: 1 }, { unique: true })

- 分析查询模式，确定创建索引的需求。
- 使用`explain("executionStats")`来监控查询性能。
- 定期审查索引，去除未使用的索引。

- 主节点（Primary）：处理客户端请求，复制操作日志。
- 从节点（Secondary）：复制主节点的操作日志并保持数据的一致性。
- 仲裁节点（Arbiter）：不存储数据，只参与投票过程，提高容错性。

// 启用分片
sh.enableSharding("myDatabase")
// 分片集合
sh.shardCollection("myDatabase.users", { username: 1 })

const mongoose = require('mongoose');
const userSchema = new mongoose.Schema({
  name: {
    type: String,
    required: [true, 'Name is required.'],
    minLength: [2, 'Name must be at least 2 characters long.']
  },
  age: {
    type: Number,
    min: [0, 'Age must be a positive number.'],
    max: [150, 'Age must be less than 150.']
  },
  email: {
    type: String,
    match: [/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/, 'Invalid email format']
  }
});
const User = mongoose.model('User', userSchema);
const user = new User({
  name: 'John',
  age: -1,
  email: 'john.doe'
});
user.save().then(doc => {
  console.log('User created:', doc);
}).catch(err => {
  console.error('Error saving user:', err.message);
});

userSchema.pre('save', function(next) {
  console.log('Before saving document');
  // Additional logic before saving the document
  next();
});
userSchema.post('save', function(doc) {
  console.log('After saving document');
  // Additional logic after the document is saved
});

// Create operation
const newUser = new User({
  name: 'Alice',
  age: 30,
  email: 'alice@example.com'
});
newUser.save().then(doc => {
  console.log('New user created:', doc);
}).catch(err => {
  console.error('Error creating user:', err.message);
});
// Read operation
User.find({}).then(users => {
  console.log('Users found:', users);
}).catch(err => {
  console.error('Error fetching users:', err.message);
});
// Update operation
User.findByIdAndUpdate(
  newUser._id,
  { $set: { age: 31 } },
  { new: true }
).then(updatedUser => {
  console.log('User updated:', updatedUser);
}).catch(err => {
  console.error('Error updating user:', err.message);
});
// Delete operation
User.findByIdAndRemove(newUser._id).then(deletedUser => {
  console.log('User deleted:', deletedUser);
}).catch(err => {
  console.error('Error deleting user:', err.message);
});

// Advanced querying with operators and conditions
User.find({ age: { $gte: 25, $lte: 35 } })
  .sort({ name: 1 })
  .limit(10)
  .skip(5)
  .then(users => {
    console.log('Users between 25 and 35, sorted, limited, and skipped:', users);
  })
  .catch(err => {
    console.error('Error querying users:', err.message);
  });

const mongoose = require('mongoose');
const { Schema } = mongoose;
const userSchema = new Schema({
  username: {
    type: String,
    required: true,
    unique: true
  },
  email: {
    type: String,
    required: true,
    unique: true
  },
  password: {
    type: String,
    required: true
  },
  createdAt: {
    type: Date,
    default: Date.now
  }
});
const User = mongoose.model('User', userSchema);
module.exports = User;

router.post('/users', async (req, res) => {
  try {
    const newUser = new User(req.body);
    await newUser.save();
    res.status(201).send({ message: 'User created successfully.', userId: newUser._id });
  } catch (error) {
    res.status(500).send({ message: 'Error creating user.' });
  }
});

router.get('/users', async (req, res) => {
  try {
    const users = await User.find();
    res.status(200).send(users);
  } catch (error) {
    res.status(500).send({ message: 'Error fetching users.' });
  }
});

router.put('/users/:id', async (req, res) => {
  try {
    const updatedUser = await User.findByIdAndUpdate(req.params.id, req.body, { new: true });
    if (!updatedUser) {
      return res.status(404).send({ message: 'User not found.' });
    }
    res.send(updatedUser);
  } catch (error) {
    res.status(500).send({ message: 'Error updating user.' });
  }
});

router.delete('/users/:id', async (req, res) => {
  try {
    const user = await User.findByIdAndDelete(req.params.id);
    if (!user) {
      return res.status(404).send({ message: 'User not found.' });
    }
    res.send({ message: 'User deleted successfully.' });
  } catch (error) {
    res.status(500).send({ message: 'Error deleting user.' });
  }
});

const postSchema = new Schema({
  title: {
    type: String,
    required: true
  },
  content: {
    type: String,
    required: true
  },
  author: {
    type: Schema.Types.ObjectId,
    ref: 'User',
    required: true
  },
  publishedAt: {
    type: Date,
    default: Date.now
  }
});
const Post = mongoose.model('Post', postSchema);
module.exports = Post;

router.post('/login', async (req, res) => {
  try {
    const user = await User.findOne({ username: req.body.username });
    if (user && await bcrypt.compare(req.body.password, user.password)) {
      const token = jwt.sign({ id: user._id }, process.env.JWT_SECRET, { expiresIn: '7d' });
      res.status(200).send({ auth: true, token: token });
    } else {
      res.status(401).send({ auth: false, message: 'Authentication failed.' });
    }
  } catch (error) {
    res.status(500).send({ message: 'Error during authentication.' });
  }
});

GET /articles                # 获取文章列表
GET /articles/:id           # 获取指定ID的文章
POST /articles              # 创建新文章
PUT /articles/:id           # 更新指定ID的文章
PATCH /articles/:id         # 部分更新指定ID的文章
DELETE /articles/:id        # 删除指定ID的文章

GET /v1/articles            # 获取旧版本的文章列表
GET /v2/articles            # 获取新版本的文章列表

GET /articles/123
HTTP/1.1 200 OK
Content-Type: application/json
{
  "id": "123",
  "title": "Understanding RESTful API",
  "content": "..."
}
POST /articles
HTTP/1.1 201 Created
Content-Type: application/json
{
  "id": "456",
  "title": "Designing RESTful APIs",
  "content": "..."
}
DELETE /articles/123
HTTP/1.1 204 No Content