生成Express后端项目脚手架

## Project Overview This project is a Node.js backend application built using the Express framework. It includes essential modules such as routing, middleware, ORM for database interactions, authentication, and logging. The application is designed to be modular and easily extensible, following best practices for backend development. ## Project Directory Structure ``` my-express-app/ ├── src/ │ ├── config/ │ │ └── config.js │ ├── controllers/ │ │ └── userController.js │ ├── middleware/ │ │ └── authMiddleware.js │ ├── models/ │ │ └── userModel.js │ ├── routes/ │ │ └── userRoutes.js │ ├── services/ │ │ └── userService.js │ ├── utils/ │ │ └── logger.js │ └── app.js ├── .env ├── package.json └── README.md ``` ## Core Files Source Code ### 1. `src/app.js` ```javascript const express = require('express'); const mongoose = require('mongoose'); const userRoutes = require('./routes/userRoutes'); const { logger } = require('./utils/logger'); require('dotenv').config(); const app = express(); app.use(express.json()); app.use('/api/users', userRoutes); const PORT = process.env.PORT || 3000; mongoose.connect(process.env.DB_URI, { useNewUrlParser: true, useUnifiedTopology: true }) .then(() => { app.listen(PORT, () => { logger.info(`Server is running on port ${PORT}`); }); }) .catch(err => { logger.error('Database connection error:', err); }); ``` ### 2. `src/routes/userRoutes.js` ```javascript const express = require('express'); const { getUsers, createUser } = require('../controllers/userController'); const { authenticate } = require('../middleware/authMiddleware'); const router = express.Router(); router.get('/', authenticate, getUsers); router.post('/', createUser); module.exports = router; ``` ### 3. `src/controllers/userController.js` ```javascript const User = require('../models/userModel'); exports.getUsers = async (req, res) => { const users = await User.find(); res.json(users); }; exports.createUser = async (req, res) => { const user = new User(req.body); await user.save(); res.status(201).json(user); }; ``` ### 4. `src/models/userModel.js` ```javascript const mongoose = require('mongoose'); const userSchema = new mongoose.Schema({ username: { type: String, required: true }, password: { type: String, required: true }, }); module.exports = mongoose.model('User', userSchema); ``` ### 5. `src/middleware/authMiddleware.js` ```javascript exports.authenticate = (req, res, next) => { // Authentication logic here (e.g., JWT verification) next(); }; ``` ### 6. `src/utils/logger.js` ```javascript const winston = require('winston'); const logger = winston.createLogger({ level: 'info', format: winston.format.json(), transports: [ new winston.transports.Console(), ], }); module.exports = { logger }; ``` ## Dependencies List ```json { "dependencies": { "express": "^4.17.1", "mongoose": "^5.10.9", "dotenv": "^8.2.0", "winston": "^3.3.3" } } ``` ## Startup Instructions 1. Clone the repository: ```bash git clone <repository-url> cd my-express-app ``` 2. Install dependencies: ```bash npm install ``` 3. Create a `.env` file in the root directory and add the following: ``` DB_URI=mongodb://<username>:<password>@localhost:27017/mydatabase PORT=3000 ``` 4. Start the application: ```bash npm start ``` 5. Access the API at `http://localhost:3000/api/users`. This setup provides a solid foundation for building a scalable backend application using Node.js and Express with MySQL as the database.

# Express.js 项目脚手架 (MySQL + 认证系统) ## Project Overview 基于 Express.js 框架的标准后端项目骨架，包含路由模块化、中间件系统、MySQL ORM 集成、JWT 认证和日志记录功能。采用分层架构设计，遵循 RESTful 最佳实践。 ## Project Directory Structure ``` express-mysql-starter/ ├── .env # 环境变量配置 ├── .gitignore ├── package.json # 项目配置与依赖 ├── README.md ├── app.js # 应用入口文件 ├── config/ # 配置目录 │ ├── database.js # 数据库配置 │ └── jwt.js # JWT 配置 ├── src/ │ ├── controllers/ # 控制器层 │ │ └── auth.controller.js │ ├── middlewares/ # 中间件 │ │ ├── auth.middleware.js │ │ └── logger.middleware.js │ ├── models/ # 数据模型 │ │ └── user.model.js │ ├── routes/ # 路由定义 │ │ ├── auth.routes.js │ │ └── index.routes.js │ ├── services/ # 业务逻辑 │ │ └── auth.service.js │ └── utils/ # 工具类 │ ├── logger.js │ └── apiError.js ├── logs/ # 日志目录 └── db/ # 数据库迁移脚本 ├── migrations/ └── seeders/ ``` ## Core Files Source Code ### 1. app.js (主入口) ```javascript require('dotenv').config(); const express = require('express'); const logger = require('./src/utils/logger'); const { sequelize } = require('./config/database'); const mainRouter = require('./src/routes/index.routes'); const app = express(); const PORT = process.env.PORT || 3000; // 中间件 app.use(express.json()); app.use(express.urlencoded({ extended: true })); app.use(require('./src/middlewares/logger.middleware')); // 路由 app.use('/api', mainRouter); // 数据库连接测试 sequelize.authenticate() .then(() => logger.info('Database connected successfully')) .catch(err => logger.error('Database connection error:', err)); // 启动服务器 app.listen(PORT, () => { logger.info(`Server running on port ${PORT}`); }); module.exports = app; ``` ### 2. MySQL 配置 (config/database.js) ```javascript const { Sequelize } = require('sequelize'); const logger = require('../src/utils/logger'); const sequelize = new Sequelize( process.env.DB_NAME, process.env.DB_USER, process.env.DB_PASSWORD, { host: process.env.DB_HOST, dialect: 'mysql', logging: msg => logger.debug(msg), pool: { max: 5, min: 0, acquire: 30000, idle: 10000 } } ); module.exports = { sequelize }; ``` ### 3. 用户模型 (src/models/user.model.js) ```javascript const { DataTypes } = require('sequelize'); const { sequelize } = require('../../config/database'); const User = sequelize.define('User', { id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true }, username: { type: DataTypes.STRING, unique: true, allowNull: false }, email: { type: DataTypes.STRING, unique: true, allowNull: false, validate: { isEmail: true } }, password: { type: DataTypes.STRING, allowNull: false }, role: { type: DataTypes.ENUM('user', 'admin'), defaultValue: 'user' } }, { timestamps: true, paranoid: true }); module.exports = User; ``` ### 4. JWT 认证中间件 (src/middlewares/auth.middleware.js) ```javascript const jwt = require('jsonwebtoken'); const ApiError = require('../utils/apiError'); const logger = require('../utils/logger'); module.exports = { authenticate: (req, res, next) => { const token = req.header('Authorization')?.replace('Bearer ', ''); if (!token) { logger.warn('Authentication failed - No token provided'); return next(new ApiError(401, 'Access denied. No token provided.')); } try { const decoded = jwt.verify(token, process.env.JWT_SECRET); req.user = decoded; next(); } catch (ex) { logger.warn(`Authentication failed - Invalid token: ${ex.message}`); next(new ApiError(400, 'Invalid token.')); } }, authorize: (roles = []) => { if (typeof roles === 'string') roles = [roles]; return (req, res, next) => { if (!roles.includes(req.user.role)) { logger.warn(`Authorization failed for role ${req.user.role}`); return next(new ApiError(403, 'Access forbidden.')); } next(); }; } }; ``` ### 5. 日志工具 (src/utils/logger.js) ```javascript const winston = require('winston'); const { combine, timestamp, printf, colorize } = winston.format; const logFormat = printf(({ level, message, timestamp }) => { return `${timestamp} [${level}]: ${message}`; }); const logger = winston.createLogger({ level: process.env.LOG_LEVEL || 'info', format: combine( colorize(), timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }), logFormat ), transports: [ new winston.transports.Console(), new winston.transports.File({ filename: 'logs/error.log', level: 'error' }), new winston.transports.File({ filename: 'logs/combined.log' }) ] }); module.exports = logger; ``` ## Dependencies List (package.json) ```json { "name": "express-mysql-starter", "version": "1.0.0", "description": "Express.js starter with MySQL and authentication", "main": "app.js", "scripts": { "start": "node app.js", "dev": "nodemon app.js", "test": "jest", "migrate": "sequelize-cli db:migrate", "seed": "sequelize-cli db:seed:all" }, "dependencies": { "bcryptjs": "^2.4.3", "dotenv": "^16.0.3", "express": "^4.18.2", "jsonwebtoken": "^9.0.0", "mysql2": "^3.2.0", "sequelize": "^6.30.0", "winston": "^3.9.0" }, "devDependencies": { "nodemon": "^2.0.22", "sequelize-cli": "^6.6.0", "jest": "^29.5.0", "supertest": "^6.3.3" } } ``` ## Startup Instructions 1. **环境准备**: ```bash # 安装 Node.js (v16+) 和 MySQL (v8+) # 克隆项目 git clone <repository-url> cd express-mysql-starter ``` 2. **安装依赖**: ```bash npm install ``` 3. **配置环境变量**: 创建 `.env` 文件并配置: ```env PORT=3000 DB_HOST=localhost DB_PORT=3306 DB_NAME=your_database DB_USER=your_username DB_PASSWORD=your_password JWT_SECRET=your_jwt_secret_key LOG_LEVEL=debug ``` 4. **数据库设置**: ```bash # 运行迁移 npx sequelize-cli db:migrate # 可选: 运行种子数据 npx sequelize-cli db:seed:all ``` 5. **启动项目**: ```bash # 开发模式 (带热重载) npm run dev # 生产模式 npm start ``` 6. **测试 API**: - 访问 `http://localhost:3000/api/health` 检查服务状态 - 使用 Postman 测试认证端点 (`/api/auth/register`, `/api/auth/login`) 7. **查看日志**: - 控制台实时输出 - 日志文件保存在 `logs/` 目录下 项目默认包含以下 API 端点: - `POST /api/auth/register` - 用户注册 - `POST /api/auth/login` - 用户登录 - `GET /api/auth/me` - 获取当前用户信息 (需要认证)

```markdown # Project Overview 本项目是一个使用 Node.js 和 Express 构建的后端应用程序模板，集成了常用的模块以支持快速开发。这些模块包括路由、ORM、认证、日志功能等，并且配置了 MySQL 数据库。此项目遵循最佳开发实践，具有良好的可扩展性。 # Project Directory Structure ``` my-express-app/ ├── src/ │ ├── config/ │ │ ├── database.js │ │ ├── logger.js │ │ └── dotenv.js │ ├── controllers/ │ │ └── authController.js │ ├── middlewares/ │ │ ├── authMiddleware.js │ │ └── loggerMiddleware.js │ ├── models/ │ │ └── user.js │ ├── routes/ │ │ └── index.js │ ├── utils/ │ │ └── errorHandler.js │ └── app.js ├── .env.example ├── package.json └── README.md ``` # Core Files Source Code ### `src/config/database.js` ```javascript const { Sequelize } = require('sequelize'); const sequelize = new Sequelize(process.env.DB_NAME, process.env.DB_USER, process.env.DB_PASSWORD, { host: process.env.DB_HOST, dialect: 'mysql', }); module.exports = sequelize; ``` ### `src/config/logger.js` ```javascript const winston = require('winston'); const logger = winston.createLogger({ level: 'info', format: winston.format.json(), transports: [ new winston.transports.Console(), ], }); module.exports = logger; ``` ### `src/config/dotenv.js` ```javascript require('dotenv').config(); ``` ### `src/controllers/authController.js` ```javascript const jwt = require('jsonwebtoken'); const User = require('../models/user'); const bcrypt = require('bcryptjs'); exports.login = async (req, res) => { // Authentication logic here }; exports.register = async (req, res) => { // User registration logic here }; ``` ### `src/middlewares/authMiddleware.js` ```javascript const jwt = require('jsonwebtoken'); module.exports = (req, res, next) => { // JWT authentication middleware logic }; ``` ### `src/middlewares/loggerMiddleware.js` ```javascript const logger = require('../config/logger'); module.exports = (req, res, next) => { logger.info(`${req.method} ${req.url}`); next(); }; ``` ### `src/models/user.js` ```javascript const { DataTypes } = require('sequelize'); const sequelize = require('../config/database'); const User = sequelize.define('User', { username: { type: DataTypes.STRING, allowNull: false, unique: true }, password: { type: DataTypes.STRING, allowNull: false } }); module.exports = User; ``` ### `src/routes/index.js` ```javascript const express = require('express'); const authController = require('../controllers/authController'); const authMiddleware = require('../middlewares/authMiddleware'); const router = express.Router(); router.post('/login', authController.login); router.post('/register', authController.register); module.exports = router; ``` ### `src/utils/errorHandler.js` ```javascript module.exports = (err, req, res, next) => { res.status(500).json({ error: err.message }); }; ``` ### `src/app.js` ```javascript const express = require('express'); const dotenv = require('./config/dotenv'); const loggerMiddleware = require('./middlewares/loggerMiddleware'); const routes = require('./routes/index'); const errorHandler = require('./utils/errorHandler'); const sequelize = require('./config/database'); const app = express(); app.use(express.json()); app.use(loggerMiddleware); app.use('/api', routes); app.use(errorHandler); const PORT = process.env.PORT || 3000; sequelize.authenticate().then(() => { console.log('Database connected.'); app.listen(PORT, () => { console.log(`Server running on port ${PORT}`); }); }).catch(err => { console.error('Unable to connect to the database:', err); }); ``` ### `.env.example` ```plaintext PORT=3000 DB_NAME=your_database_name DB_USER=your_username DB_PASSWORD=your_password DB_HOST=localhost JWT_SECRET=your_jwt_secret ``` # Dependencies List - express - sequelize - mysql2 - dotenv - winston - jsonwebtoken - bcryptjs # Startup Instructions 1. **Clone the repository**: ```bash git clone <repository-url> ``` 2. **Navigate into the project directory**: ```bash cd my-express-app ``` 3. **Install dependencies**: ```bash npm install ``` 4. **Copy the `.env.example` to `.env` and fill in your credentials**. 5. **Run the application**: ```bash npm start ``` 6. **Access the server** at `http://localhost:3000`. ```

# Project Overview This project is a Node.js application using the Express framework. It includes essential modules such as routing, middleware, ORM (using Sequelize for MySQL), authentication (using JWT), and logging. The project structure is designed to be modular and scalable, adhering to best practices in backend development. # Project Directory Structure ``` /project-name │ ├── /config │ └── db.config.js │ ├── /controllers │ └── auth.controller.js │ ├── /middlewares │ ├── auth.middleware.js │ └── logger.middleware.js │ ├── /models │ └── user.model.js │ ├── /routes │ └── auth.routes.js │ ├── /utils │ └── jwt.utils.js │ ├── .env ├── app.js ├── package.json └── server.js ``` # Core Files Source Code ## `/config/db.config.js` ```javascript const { Sequelize } = require('sequelize'); const sequelize = new Sequelize(process.env.DB_NAME, process.env.DB_USER, process.env.DB_PASSWORD, { host: process.env.DB_HOST, dialect: 'mysql', }); module.exports = sequelize; ``` ## `/controllers/auth.controller.js` ```javascript const jwt = require('jsonwebtoken'); const bcrypt = require('bcryptjs'); const User = require('../models/user.model'); exports.register = async (req, res) => { try { const hashedPassword = await bcrypt.hash(req.body.password, 8); const user = await User.create({ username: req.body.username, password: hashedPassword }); res.status(201).send(user); } catch (error) { res.status(500).send(error); } }; exports.login = async (req, res) => { try { const user = await User.findOne({ where: { username: req.body.username } }); if (!user || !(await bcrypt.compare(req.body.password, user.password))) { return res.status(401).send({ message: 'Invalid Credentials' }); } const token = jwt.sign({ id: user.id }, process.env.JWT_SECRET, { expiresIn: 86400 }); // 24 hours res.status(200).send({ auth: true, token }); } catch (error) { res.status(500).send(error); } }; ``` ## `/middlewares/auth.middleware.js` ```javascript const jwt = require('jsonwebtoken'); const verifyToken = (req, res, next) => { const token = req.headers['x-access-token']; if (!token) { return res.status(403).send({ message: 'No token provided!' }); } jwt.verify(token, process.env.JWT_SECRET, (err, decoded) => { if (err) { return res.status(401).send({ message: 'Unauthorized!' }); } req.userId = decoded.id; next(); }); }; module.exports = verifyToken; ``` ## `/middlewares/logger.middleware.js` ```javascript const logger = (req, res, next) => { console.log(`${new Date().toISOString()} - ${req.method} ${req.url}`); next(); }; module.exports = logger; ``` ## `/models/user.model.js` ```javascript const { DataTypes } = require('sequelize'); const sequelize = require('../config/db.config'); const User = sequelize.define('User', { username: { type: DataTypes.STRING, allowNull: false, unique: true, }, password: { type: DataTypes.STRING, allowNull: false, }, }); module.exports = User; ``` ## `/routes/auth.routes.js` ```javascript const express = require('express'); const router = express.Router(); const authController = require('../controllers/auth.controller'); const authMiddleware = require('../middlewares/auth.middleware'); router.post('/register', authController.register); router.post('/login', authController.login); module.exports = router; ``` ## `/utils/jwt.utils.js` ```javascript const jwt = require('jsonwebtoken'); const generateToken = (userId) => { return jwt.sign({ id: userId }, process.env.JWT_SECRET, { expiresIn: 86400 }); // 24 hours }; module.exports = generateToken; ``` ## `.env` ``` DB_NAME=your_db_name DB_USER=your_db_user DB_PASSWORD=your_db_password DB_HOST=localhost JWT_SECRET=your_jwt_secret ``` ## `app.js` ```javascript const express = require('express'); const bodyParser = require('body-parser'); const loggerMiddleware = require('./middlewares/logger.middleware'); const authRoutes = require('./routes/auth.routes'); const app = express(); app.use(bodyParser.json()); app.use(loggerMiddleware); app.use('/api/auth', authRoutes); module.exports = app; ``` ## `server.js` ```javascript const app = require('./app'); const sequelize = require('./config/db.config'); const PORT = process.env.PORT || 3000; sequelize.sync() .then(() => { app.listen(PORT, () => { console.log(`Server is running on port ${PORT}.`); }); }) .catch((err) => { console.error('Unable to connect to the database:', err); }); ``` # Dependencies List ```json { "dependencies": { "bcryptjs": "^2.4.3", "dotenv": "^16.0.3", "express": "^4.18.2", "jsonwebtoken": "^9.0.0", "mysql2": "^3.1.0", "sequelize": "^6.28.0" } } ``` # Startup Instructions 1. Clone the repository. 2. Install dependencies: ```bash npm install ``` 3. Set up your environment variables in the `.env` file. 4. Start the server: ```bash node server.js ``` 5. The server will start on `http://localhost:3000`. You can test the API endpoints using tools like Postman or curl.