构建一个Express MVC API：代码示例与最佳实践

Express是一个流行的Node.js框架，用于构建Web应用程序和API。MVC（模型-视图-控制器）是一种设计模式，用于将应用程序的逻辑和数据分开。本文将向您展示如何使用Express构建一个完整的MVC API系统。

1. 项目设置

首先，我们需要创建一个新的Node.js项目。您可以使用以下命令：

mkdir my-api
cd my-api
npm init -y

接下来，我们需要安装Express框架。

npm install express

2. 创建模型

模型是表示应用程序数据结构的类。在我们的API中，我们将使用模型来表示用户、文章和评论。

// user.model.js
const mongoose = require('mongoose');

const userSchema = new mongoose.Schema({
  name: { type: String, required: true },
  email: { type: String, required: true, unique: true },
  password: { type: String, required: true }
});

const User = mongoose.model('User', userSchema);

module.exports = User;

// article.model.js
const mongoose = require('mongoose');

const articleSchema = new mongoose.Schema({
  title: { type: String, required: true },
  content: { type: String, required: true },
  author: { type: mongoose.Schema.Types.ObjectId, ref: 'User' }
});

const Article = mongoose.model('Article', articleSchema);

module.exports = Article;

// comment.model.js
const mongoose = require('mongoose');

const commentSchema = new mongoose.Schema({
  content: { type: String, required: true },
  author: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
  article: { type: mongoose.Schema.Types.ObjectId, ref: 'Article' }
});

const Comment = mongoose.model('Comment', commentSchema);

module.exports = Comment;

3. 创建路由

路由是处理客户端请求的函数。在我们的API中，我们将使用路由来处理用户、文章和评论的增删改查操作。

// user.route.js
const express = require('express');
const router = express.Router();

const User = require('../models/user.model');

router.get('/users', async (req, res) => {
  const users = await User.find();
  res.json(users);
});

router.post('/users', async (req, res) => {
  const user = new User(req.body);
  await user.save();
  res.json(user);
});

router.put('/users/:id', async (req, res) => {
  const user = await User.findByIdAndUpdate(req.params.id, req.body);
  res.json(user);
});

router.delete('/users/:id', async (req, res) => {
  await User.findByIdAndDelete(req.params.id);
  res.json({ message: 'User deleted' });
});

module.exports = router;

// article.route.js
const express = require('express');
const router = express.Router();

const Article = require('../models/article.model');

router.get('/articles', async (req, res) => {
  const articles = await Article.find().populate('author');
  res.json(articles);
});

router.post('/articles', async (req, res) => {
  const article = new Article(req.body);
  await article.save();
  res.json(article);
});

router.put('/articles/:id', async (req, res) => {
  const article = await Article.findByIdAndUpdate(req.params.id, req.body);
  res.json(article);
});

router.delete('/articles/:id', async (req, res) => {
  await Article.findByIdAndDelete(req.params.id);
  res.json({ message: 'Article deleted' });
});

module.exports = router;

// comment.route.js
const express = require('express');
const router = express.Router();

const Comment = require('../models/comment.model');

router.get('/comments', async (req, res) => {
  const comments = await Comment.find().populate('author').populate('article');
  res.json(comments);
});

router.post('/comments', async (req, res) => {
  const comment = new Comment(req.body);
  await comment.save();
  res.json(comment);
});

router.put('/comments/:id', async (req, res) => {
  const comment = await Comment.findByIdAndUpdate(req.params.id, req.body);
  res.json(comment);
});

router.delete('/comments/:id', async (req, res) => {
  await Comment.findByIdAndDelete(req.params.id);
  res.json({ message: 'Comment deleted' });
});

module.exports = router;

4. 创建控制器

控制器是处理业务逻辑的类。在我们的API中，我们将使用控制器来处理用户、文章和评论的增删改查操作。

// user.controller.js
const UserService = require('../services/user.service');

class UserController {
  static async getUsers(req, res) {
    const users = await UserService.getUsers();
    res.json(users);
  }

  static async createUser(req, res) {
    const user = await UserService.createUser(req.body);
    res.json(user);
  }

  static async updateUser(req, res) {
    const user = await UserService.updateUser(req.params.id, req.body);
    res.json(user);
  }

  static async deleteUser(req, res) {
    await UserService.deleteUser(req.params.id);
    res.json({ message: 'User deleted' });
  }
}

module.exports = UserController;

// article.controller.js
const ArticleService = require('../services/article.service');

class ArticleController {
  static async getArticles(req, res) {
    const articles = await ArticleService.getArticles();
    res.json(articles);
  }

  static async createArticle(req, res) {
    const article = await ArticleService.createArticle(req.body);
    res.json(article);
  }

  static async updateArticle(req, res) {
    const article = await ArticleService.updateArticle(req.params.id, req.body);
    res.json(article);
  }

  static async deleteArticle(req, res) {
    await ArticleService.deleteArticle(req.params.id);
    res.json({ message: 'Article deleted' });
  }
}

module.exports = ArticleController;

// comment.controller.js
const CommentService = require('../services/comment.service');

class CommentController {
  static async getComments(req, res) {
    const comments = await CommentService.getComments();
    res.json(comments);
  }

  static async createComment(req, res) {
    const comment = await CommentService.createComment(req.body);
    res.json(comment);
  }

  static async updateComment(req, res) {
    const comment = await CommentService.updateComment(req.params.id, req.body);
    res.json(comment);
  }

  static async deleteComment(req, res) {
    await CommentService.deleteComment(req.params.id);
    res.json({ message: 'Comment deleted' });
  }
}

module.exports = CommentController;

5. 创建服务

服务是处理数据访问的类。在我们的API中，我们将使用服务来处理用户、文章和评论的数据访问操作。

// user.service.js
const User = require('../models/user.model');

class UserService {
  static async getUsers() {
    return await User.find();
  }

  static async createUser(data) {
    const user = new User(data);
    return await user.save();
  }

  static async updateUser(id, data) {
    return await User.findByIdAndUpdate(id, data);
  }

  static async deleteUser(id) {
    return await User.findByIdAndDelete(id