Express(Mongoose)多数据类型接口重复代码优化方案问询

嘿，我太懂你这种被重复代码淹没的感受了——每个Mongoose模型都写一遍CRUD接口，不仅写得烦，以后改个错误提示或者逻辑都要挨个文件改，简直是维护噩梦。针对你用Express+Mongoose开发REST API的场景，咱们可以用通用CRUD工厂函数来彻底解决这个重复代码的问题，下面给你一步步拆解实现：

第一步：创建通用CRUD工厂函数 #

新建一个工具文件（比如utils/crudFactory.js），把所有模型通用的CRUD逻辑封装成一个工厂函数，接收Mongoose模型作为参数，返回对应的处理函数：

// utils/crudFactory.js
export const createCrudHandlers = (Model) => {
  // 通用：根据ID删除
  const deleteById = async (req, res, next) => {
    try {
      const deletedItem = await Model.findByIdAndRemove(req.params.id);
      if (!deletedItem) {
        const error = new Error(`${Model.modelName} not found`);
        error.statusCode = 404;
        throw error;
      }
      res.status(200).json({ message: `${Model.modelName} deleted successfully` });
    } catch (err) {
      const error = new Error(`Failed to delete ${Model.modelName.toLowerCase()}: ${err.message}`);
      error.statusCode = err.statusCode || 500;
      next(error);
    }
  };

  // 通用：获取所有数据
  const getAll = async (req, res, next) => {
    try {
      const items = await Model.find({});
      res.status(200).json(items);
    } catch (err) {
      const error = new Error(`Failed to fetch ${Model.modelName.toLowerCase()}s: ${err.message}`);
      error.statusCode = 500;
      next(error);
    }
  };

  // 通用：根据ID获取单条数据
  const getById = async (req, res, next) => {
    try {
      const item = await Model.findById(req.params.id);
      if (!item) {
        const error = new Error(`${Model.modelName} not found`);
        error.statusCode = 404;
        throw error;
      }
      res.status(200).json(item);
    } catch (err) {
      const error = new Error(`Failed to fetch ${Model.modelName.toLowerCase()}: ${err.message}`);
      error.statusCode = 500;
      next(error);
    }
  };

  // 通用：创建数据
  const create = async (req, res, next) => {
    try {
      const newItem = new Model(req.body);
      const savedItem = await newItem.save();
      res.status(201).json(savedItem);
    } catch (err) {
      const error = new Error(`Failed to create ${Model.modelName.toLowerCase()}: ${err.message}`);
      error.statusCode = 500;
      next(error);
    }
  };

  // 通用：根据ID更新数据
  const updateById = async (req, res, next) => {
    try {
      const updatedItem = await Model.findByIdAndUpdate(
        req.params.id,
        req.body,
        { new: true, runValidators: true } // 返回更新后的数据，并且运行模型验证规则
      );
      if (!updatedItem) {
        const error = new Error(`${Model.modelName} not found`);
        error.statusCode = 404;
        throw error;
      }
      res.status(200).json(updatedItem);
    } catch (err) {
      const error = new Error(`Failed to update ${Model.modelName.toLowerCase()}: ${err.message}`);
      error.statusCode = 500;
      next(error);
    }
  };

  return {
    getAll,
    getById,
    create,
    updateById,
    deleteById
  };
};

第二步：在路由中复用工厂函数 #

现在不管是Book、User还是Food模型，都可以直接调用这个工厂函数生成CRUD处理函数，不用再重复写逻辑了：

示例：Book模型路由 #

// routes/bookRoutes.js
import express from 'express';
import Book from '../models/Book';
import { createCrudHandlers } from '../utils/crudFactory';

const router = express.Router();
const bookHandlers = createCrudHandlers(Book);

// 直接绑定通用处理函数
router.get('/', bookHandlers.getAll);
router.get('/:id', bookHandlers.getById);
router.post('/', bookHandlers.create);
router.put('/:id', bookHandlers.updateById);
router.delete('/:id', bookHandlers.deleteById);

export default router;

示例：User模型路由（支持特殊逻辑覆盖） #

如果某个模型有特殊业务需求（比如用户注册需要加密密码），可以单独覆盖对应的方法，不影响其他通用逻辑：

// routes/userRoutes.js
import express from 'express';
import User from '../models/User';
import { createCrudHandlers } from '../utils/crudFactory';
import { encryptPassword } from '../utils/passwordUtils'; // 假设你有密码加密工具

const router = express.Router();
const userHandlers = createCrudHandlers(User);

// 通用逻辑直接用
router.get('/', userHandlers.getAll);
router.get('/:id', userHandlers.getById);

// 覆盖create方法，添加密码加密逻辑
router.post('/', async (req, res, next) => {
  try {
    // 特殊处理：加密密码
    req.body.password = await encryptPassword(req.body.password);
    // 调用通用create方法完成后续逻辑
    await userHandlers.create(req, res, next);
  } catch (err) {
    next(err);
  }
});

router.put('/:id', userHandlers.updateById);
router.delete('/:id', userHandlers.deleteById);

export default router;

为什么这种方式好用？ #

• 减少重复代码：通用逻辑只写一次，所有模型共享
• 易维护：如果要修改错误提示格式、CRUD逻辑，只需要在crudFactory.js里改一次，所有模型自动生效
• 灵活性高：支持单个模型覆盖特殊逻辑，不破坏通用规则
• 代码更清晰：路由文件只需要关注路由绑定，不用再堆满重复的业务逻辑

内容的提问来源于stack exchange，提问作者Hansen W