express常见的规范以及各模块的作用与使用方式

+---------------------+       +---------------------+       +---------------------+
|      app.js         |<----->|     routes/         |<----->|   controllers/       |
+---------------------+       +---------------------+       +---------------------+
        ^                       ^                       ^
        |                       |                       |
        v                       v                       v
+---------------------+       +---------------------+       +---------------------+
|     config/         |       |   middlewares/      |       |     services/        |
+---------------------+       +---------------------+       +---------------------+
        ^                       ^                       ^
        |                       |                       |
        v                       v                       v
+--------------------------------------------------------------------------+
                                |
                                v
                        +---------------------+
                        |     models/         |
                        +---------------------+
                                |
                                v
                        +---------------------+
                        |     utils/          |
                        +---------------------+

在Express框架中进行模块化开发可以提高代码的可维护性和可扩展性。以下是一些常见的规范以及各模块的作用与使用方式：

1. 项目结构

一个典型的Express项目结构可能如下：

myapp/
├── app.js
├── bin/
│   └── www
├── config/
│   ├── db.js
│   └── config.js
├── controllers/
│   ├── userController.js
│   └── postController.js
├── middlewares/
│   ├── auth.js
│   └── logger.js
├── models/
│   ├── userModel.js
│   └── postModel.js
├── routes/
│   ├── userRoutes.js
│   └── postRoutes.js
├── services/
│   ├── userService.js
│   └── postService.js
└── utils/
    ├── helpers.js
    └── constants.js

2. 模块作用与使用方式

app.js

• 作用: 应用的入口文件，配置全局中间件、路由等。
• 使用方式:

  const express = require('express');
  const app = express();
  const bodyParser = require('body-parser');
  
  // 使用中间件
  app.use(bodyParser.json());
  
  // 引入路由
  const userRoutes = require('./routes/userRoutes');
  app.use('/api/users', userRoutes);
  
  module.exports = app;
  

bin/www

• 作用: 启动服务器。
• 使用方式:

  #!/usr/bin/env node
  
  const app = require('../app');
  const http = require('http');
  
  const port = normalizePort(process.env.PORT || '3000');
  app.set('port', port);
  
  const server = http.createServer(app);
  server.listen(port);
  server.on('error', one rror);
  server.on('listening', onListening);
  
  function normalizePort(val) {
    const port = parseInt(val, 10);
    if (isNaN(port)) return val;
    if (port >= 0) return port;
    return false;
  }
  
  function one rror(error) {
    if (error.syscall !== 'listen') throw error;
    const bind = typeof port === 'string' ? 'Pipe ' + port : 'Port ' + port;
    switch (error.code) {
      case 'EACCES':
        console.error(bind + ' requires elevated privileges');
        process.exit(1);
        break;
      case 'EADDRINUSE':
        console.error(bind + ' is already in use');
        process.exit(1);
        break;
      default:
        throw error;
    }
  }
  
  function onListening() {
    const addr = server.address();
    const bind = typeof addr === 'string' ? 'pipe ' + addr : 'port ' + addr.port;
    console.log('Listening on ' + bind);
  }
  

config/

• 作用: 存放配置文件，如数据库连接、环境变量等。
• 使用方式:

  // config/db.js
  const mongoose = require('mongoose');
  
  const connectDB = async () => {
    try {
      await mongoose.connect(process.env.MONGO_URI, {
        useNewUrlParser: true,
        useUnifiedTopology: true,
      });
      console.log('MongoDB connected');
    } catch (err) {
      console.error(err.message);
      process.exit(1);
    }
  };
  
  module.exports = connectDB;
  

controllers/

• 作用: 处理业务逻辑，调用服务层，返回响应。
• 使用方式:

  // controllers/userController.js
  const userService = require('../services/userService');
  
  exports.getUsers = async (req, res) => {
    try {
      const users = await userService.getUsers();
      res.json(users);
    } catch (err) {
      res.status(500).json({ message: err.message });
    }
  };
  

middlewares/

• 作用: 自定义中间件，如身份验证、日志记录等。
• 使用方式:

  // middlewares/auth.js
  const jwt = require('jsonwebtoken');
  
  const auth = (req, res, next) => {
    const token = req.header('x-auth-token');
    if (!token) return res.status(401).json({ message: 'Access denied. No token provided.' });
  
    try {
      const decoded = jwt.verify(token, 'your_jwt_secret');
      req.user = decoded;
      next();
    } catch (ex) {
      res.status(400).json({ message: 'Invalid token.' });
    }
  };
  
  module.exports = auth;
  

models/

• 作用: 定义数据模型，通常与数据库交互。
• 使用方式:

  // models/userModel.js
  const mongoose = require('mongoose');
  
  const userSchema = new mongoose.Schema({
    name: String,
    email: { type: String, unique: true },
    password: String,
  });
  
  module.exports = mongoose.model('User', userSchema);
  

routes/

• 作用: 定义路由，将请求映射到控制器。
• 使用方式:

  // routes/userRoutes.js
  const express = require('express');
  const router = express.Router();
  const userController = require('../controllers/userController');
  const auth = require('../middlewares/auth');
  
  router.get('/users', auth, userController.getUsers);
  
  module.exports = router;
  

services/

• 作用: 处理业务逻辑，调用模型层，进行数据处理。
• 使用方式:

  // services/userService.js
  const User = require('../models/userModel');
  
  exports.getUsers = async () => {
    return await User.find();
  };
  

utils/

• 作用: 存放工具函数和常量。
• 使用方式:

  // utils/helpers.js
  exports.formatDate = (date) => {
    return date.toISOString().split('T')[0];
  };
  

总结

通过模块化开发，可以将不同的功能分离到不同的文件和目录中，使得代码更加清晰、易于维护。每个模块都有明确的职责，便于团队协作和代码复用。