基于Express与MVC架构的Node.js博客平台后端开发实战

在实际的毕业设计或课程项目中，选择一个技术栈清晰、功能完整且易于扩展的课题至关重要。一个基于 Node.js 的博客交流平台，结合 Express 框架、MySQL 数据库以及 MVC 架构，是理解现代 Web 后端开发流程的绝佳实践。很多同学在搭建这类项目时，往往卡在如何将零散的技术点（如路由、控制器、数据库操作）串联成一个可运行、可维护的系统上，或者写出的代码结构混乱，难以应对开题、中期、答辩等环节的审查。

本文将围绕一个真实的“Express 博客交流平台”毕业设计项目，从零开始拆解其核心实现。我们将重点关注如何设计一个清晰的 MVC 架构，特别是 Express 中路由（Router）与控制器（Controller）的职责分离，以及如何与 MySQL 数据库进行安全、高效的交互。通过本文，你将能掌握一个具备用户认证、文章发布、评论互动等核心功能的博客平台后端搭建全过程，并获得可复用的源码结构与工程化实践，为你的毕业设计或项目实战提供扎实的参考。

1. 理解项目架构：为什么选择 Express + MVC + MySQL？

在开始编码之前，明确技术选型背后的原因，能帮助你在设计和排查问题时更有方向。

1.1 Node.js 与 Express 框架的定位

Node.js 是一个基于 Chrome V8 引擎的 JavaScript 运行时，其非阻塞 I/O 和事件驱动特性使其特别适合 I/O 密集型的 Web 应用，如内容管理系统、实时应用和 API 服务。Express 是 Node.js 生态中最流行的 Web 应用框架，它封装了底层的 HTTP 模块，提供了路由、中间件、模板引擎集成等强大功能，极大地简化了 Web 服务器的开发。对于毕业设计而言，Express 学习曲线平缓，社区资源丰富，能让你快速聚焦于业务逻辑而非底层细节。

1.2 MVC 模式在 Express 中的体现

MVC（Model-View-Controller）是一种经典的设计模式，旨在分离数据、界面和控制逻辑，提升代码的可维护性和可测试性。在 Express 项目中，我们通常这样映射：

• Model（模型）：负责与数据库交互，定义数据结构和业务规则。通常对应models/目录下的文件，使用 Sequelize、Prisma 等 ORM 或直接编写 SQL。
• View（视图）：负责渲染用户界面。在前后端分离的架构中，这部分通常由前端框架（如 Vue、React）完成，后端仅提供 API。如果使用服务端渲染，则可能对应views/目录下的模板（如 EJS、Pug）。
• Controller（控制器）：作为 Model 和 View 之间的协调者，处理请求、调用 Model 获取数据、处理业务逻辑，并决定返回何种响应。通常对应controllers/目录下的文件。
• Router（路由）：在 Express 中，路由负责将不同的 HTTP 请求（GET、POST 等）映射到对应的控制器方法。它定义了应用的端点（URI）和响应方式，是请求进入应用的第一站。

一个清晰的架构应该是：路由定义 URL 路径 -> 控制器处理具体请求 -> 模型操作数据库。

1.3 MySQL 作为数据存储的选择

MySQL 是一款成熟、稳定、开源的关系型数据库，拥有完善的 ACID 特性，适合存储博客平台中具有明确关系的数据，如用户、文章、评论、分类等。其丰富的查询语言（SQL）和事务支持，能很好地处理文章发布、评论关联、用户权限等业务场景。对于学习而言，理解关系型数据库的设计和 SQL 操作是后端开发的基本功。

2. 环境准备与项目初始化

在开始编码前，需要搭建一个统一的开发环境。以下步骤假设你使用的是 Windows、macOS 或 Linux 系统。

2.1 安装 Node.js 与 npm

访问 Node.js 官方网站，下载并安装 LTS（长期支持）版本。安装完成后，打开终端或命令提示符，验证安装是否成功：

node -v npm -v

正常情况会输出类似v18.17.0和9.6.7的版本号。npm 是 Node.js 的包管理器，用于安装项目依赖。

注意：如果遇到网络问题导致 npm 安装包缓慢，可以配置国内镜像源，例如使用npm config set registry https://registry.npmmirror.com。

2.2 安装与配置 MySQL

1. 下载安装：访问 MySQL 官方网站，下载社区版（MySQL Community Server）安装包。按照安装向导进行，过程中会提示设置 root 用户的密码，请务必牢记。
2. 启动服务：安装完成后，确保 MySQL 服务已启动。在 Windows 服务中查找 “MySQL80” 或类似服务；在 macOS/Linux 上可以使用sudo systemctl start mysql命令。
3. 连接验证：使用命令行客户端或图形化工具（如 MySQL Workbench）连接数据库。在终端中执行：

   mysql -u root -p

   输入密码后，看到mysql>提示符即表示连接成功。
4. 创建项目数据库：

   CREATE DATABASE IF NOT EXISTS blog_platform CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci; USE blog_platform;

   这里指定了utf8mb4字符集，以支持存储 Emoji 等特殊字符。

2.3 初始化 Express 项目

1. 创建一个新的项目目录并进入：

   mkdir express-blog-platform cd express-blog-platform

2. 初始化package.json文件：

   npm init -y

3. 安装 Express 框架和开发所需的常用依赖：

   npm install express mysql2 dotenv cors helmet npm install --save-dev nodemon

   • express: Web 框架核心。
   • mysql2: MySQL 数据库驱动，性能优于mysql包，并支持 Promise。
   • dotenv: 用于从.env文件加载环境变量，便于管理数据库密码等敏感信息。
   • cors: 处理跨域资源共享，方便前后端分离开发。
   • helmet: 通过设置一系列 HTTP 头来增强应用安全性。
   • nodemon: 开发工具，监听文件变化自动重启服务器。

2.4 项目基础结构规划

在项目根目录下，创建以下目录和文件，形成清晰的 MVC 结构：

express-blog-platform/ ├── node_modules/ # 依赖包（自动生成） ├── config/ # 配置文件 │ └── database.js # 数据库连接配置 ├── controllers/ # 控制器 │ ├── authController.js # 认证相关（登录、注册） │ ├── postController.js # 文章相关 │ └── commentController.js # 评论相关 ├── models/ # 数据模型 │ ├── User.js │ ├── Post.js │ └── Comment.js ├── routes/ # 路由定义 │ ├── authRoutes.js │ ├── postRoutes.js │ └── commentRoutes.js ├── middleware/ # 自定义中间件 │ └── authMiddleware.js # 认证中间件 ├── utils/ # 工具函数 │ └── logger.js # 日志工具 ├── .env # 环境变量（切勿提交到Git） ├── .gitignore # Git忽略文件 ├── app.js # Express应用主入口 └── package.json

3. 核心模块实现：从数据库到 API

我们将按照数据流的方向，从底层的数据模型开始，逐步向上实现控制器和路由。

3.1 数据库设计与模型层（Model）

首先，在 MySQL 中创建三张核心表。在mysql>命令行中执行：

-- 用户表 CREATE TABLE users ( id INT AUTO_INCREMENT PRIMARY KEY, username VARCHAR(50) UNIQUE NOT NULL, email VARCHAR(100) UNIQUE NOT NULL, password_hash VARCHAR(255) NOT NULL, -- 存储加密后的密码 avatar_url VARCHAR(255) DEFAULT NULL, bio TEXT, created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP ); -- 文章表 CREATE TABLE posts ( id INT AUTO_INCREMENT PRIMARY KEY, title VARCHAR(200) NOT NULL, content TEXT NOT NULL, excerpt VARCHAR(500), -- 文章摘要 cover_image VARCHAR(255), author_id INT NOT NULL, category_id INT DEFAULT NULL, view_count INT DEFAULT 0, status ENUM('draft', 'published', 'archived') DEFAULT 'draft', published_at TIMESTAMP NULL, created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP, FOREIGN KEY (author_id) REFERENCES users(id) ON DELETE CASCADE -- 实际项目中可能还有分类表，此处简化处理 ); -- 评论表 CREATE TABLE comments ( id INT AUTO_INCREMENT PRIMARY KEY, content TEXT NOT NULL, post_id INT NOT NULL, user_id INT NOT NULL, parent_id INT DEFAULT NULL, -- 用于实现回复功能 created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, FOREIGN KEY (post_id) REFERENCES posts(id) ON DELETE CASCADE, FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE, FOREIGN KEY (parent_id) REFERENCES comments(id) ON DELETE CASCADE );

接下来，在config/database.js中配置数据库连接，使用dotenv管理敏感信息：

// config/database.js const mysql = require('mysql2/promise'); // 使用 Promise 版本 require('dotenv').config(); // 加载 .env 文件 const pool = mysql.createPool({ host: process.env.DB_HOST || 'localhost', user: process.env.DB_USER || 'root', password: process.env.DB_PASSWORD, // 从环境变量读取 database: process.env.DB_NAME || 'blog_platform', waitForConnections: true, connectionLimit: 10, // 连接池大小 queueLimit: 0 }); module.exports = pool;

在项目根目录创建.env文件，并填入你的数据库信息（此文件需加入.gitignore）：

# .env DB_HOST=localhost DB_USER=root DB_PASSWORD=your_mysql_password_here DB_NAME=blog_platform NODE_ENV=development PORT=3000 JWT_SECRET=your_super_secret_jwt_key_here

然后，创建模型文件。以models/User.js为例，这里我们不使用完整的 ORM，而是封装基础的 SQL 操作，以便更清晰地理解原理：

// models/User.js const db = require('../config/database'); const bcrypt = require('bcryptjs'); // 需要安装：npm install bcryptjs class User { // 根据用户名查找用户 static async findByUsername(username) { const [rows] = await db.execute('SELECT * FROM users WHERE username = ?', [username]); return rows[0]; // 返回第一个用户对象或 undefined } // 根据ID查找用户（不返回密码） static async findById(id) { const [rows] = await db.execute('SELECT id, username, email, avatar_url, bio, created_at FROM users WHERE id = ?', [id]); return rows[0]; } // 创建新用户 static async create(userData) { const { username, email, password } = userData; // 对密码进行哈希处理 const salt = await bcrypt.genSalt(10); const passwordHash = await bcrypt.hash(password, salt); const [result] = await db.execute( 'INSERT INTO users (username, email, password_hash) VALUES (?, ?, ?)', [username, email, passwordHash] ); return result.insertId; // 返回新用户的ID } // 验证密码 static async verifyPassword(plainPassword, hashedPassword) { return await bcrypt.compare(plainPassword, hashedPassword); } } module.exports = User;

models/Post.js和models/Comment.js的结构类似，包含如findAll,findById,create,update,delete等针对各自表的基础 CRUD 方法。

3.2 控制器层（Controller）实现

控制器是业务逻辑的核心。以认证控制器controllers/authController.js为例：

// controllers/authController.js const User = require('../models/User'); const jwt = require('jsonwebtoken'); // 需要安装：npm install jsonwebtoken require('dotenv').config(); const authController = { // 用户注册 async register(req, res) { try { const { username, email, password } = req.body; // 1. 基础验证 if (!username || !email || !password) { return res.status(400).json({ error: '用户名、邮箱和密码均为必填项' }); } // 2. 检查用户是否已存在 const existingUser = await User.findByUsername(username); if (existingUser) { return res.status(409).json({ error: '用户名已被占用' }); } // 3. 创建用户 const userId = await User.create({ username, email, password }); // 4. 生成JWT令牌（自动登录） const token = jwt.sign( { userId, username }, process.env.JWT_SECRET, { expiresIn: '7d' } // 令牌有效期7天 ); res.status(201).json({ message: '注册成功', token, user: { id: userId, username, email } }); } catch (error) { console.error('注册错误:', error); res.status(500).json({ error: '服务器内部错误，注册失败' }); } }, // 用户登录 async login(req, res) { try { const { username, password } = req.body; // 1. 查找用户 const user = await User.findByUsername(username); if (!user) { return res.status(401).json({ error: '用户名或密码错误' }); } // 2. 验证密码 const isValid = await User.verifyPassword(password, user.password_hash); if (!isValid) { return res.status(401).json({ error: '用户名或密码错误' }); } // 3. 生成JWT令牌 const token = jwt.sign( { userId: user.id, username: user.username }, process.env.JWT_SECRET, { expiresIn: '7d' } ); // 4. 返回用户信息（排除密码） const { password_hash, ...userInfo } = user; res.json({ message: '登录成功', token, user: userInfo }); } catch (error) { console.error('登录错误:', error); res.status(500).json({ error: '服务器内部错误，登录失败' }); } }, // 获取当前用户信息（受保护路由） async getMe(req, res) { // req.user 由认证中间件附加（见下文） try { const user = await User.findById(req.user.userId); if (!user) { return res.status(404).json({ error: '用户不存在' }); } res.json({ user }); } catch (error) { console.error('获取用户信息错误:', error); res.status(500).json({ error: '服务器内部错误' }); } } }; module.exports = authController;

文章控制器controllers/postController.js则需要处理文章列表、详情、创建、更新和删除，并注意权限控制（例如，只有作者本人可以修改或删除自己的文章）。

3.3 路由层（Router）定义与中间件

路由文件将 HTTP 端点与控制器方法绑定。创建routes/authRoutes.js：

// routes/authRoutes.js const express = require('express'); const router = express.Router(); const authController = require('../controllers/authController'); const authMiddleware = require('../middleware/authMiddleware'); // 认证中间件 // 公开路由 router.post('/register', authController.register); router.post('/login', authController.login); // 受保护的路由，需要有效的 JWT Token router.get('/me', authMiddleware, authController.getMe); module.exports = router;

关键的authMiddleware用于验证请求头中的 JWT 令牌。创建middleware/authMiddleware.js：

// middleware/authMiddleware.js const jwt = require('jsonwebtoken'); require('dotenv').config(); const authMiddleware = (req, res, next) => { // 从请求头获取 token，格式通常为：Authorization: Bearer <token> const authHeader = req.headers.authorization; if (!authHeader || !authHeader.startsWith('Bearer ')) { return res.status(401).json({ error: '访问被拒绝，未提供认证令牌' }); } const token = authHeader.split(' ')[1]; // 提取 token try { const decoded = jwt.verify(token, process.env.JWT_SECRET); // 将解码后的用户信息附加到请求对象上，供后续控制器使用 req.user = decoded; next(); // 验证通过，继续下一个中间件或路由处理器 } catch (error) { if (error.name === 'TokenExpiredError') { return res.status(401).json({ error: '令牌已过期，请重新登录' }); } return res.status(401).json({ error: '无效的认证令牌' }); } }; module.exports = authMiddleware;

文章路由routes/postRoutes.js则会更加复杂，需要区分公开接口和受保护接口：

// routes/postRoutes.js const express = require('express'); const router = express.Router(); const postController = require('../controllers/postController'); const authMiddleware = require('../middleware/authMiddleware'); // 公开：获取文章列表、获取单篇文章 router.get('/', postController.getAllPosts); router.get('/:id', postController.getPostById); // 受保护：创建、更新、删除文章（需要登录） router.post('/', authMiddleware, postController.createPost); router.put('/:id', authMiddleware, postController.updatePost); router.delete('/:id', authMiddleware, postController.deletePost); module.exports = router;

3.4 应用主入口与全局配置

最后，在app.js中整合所有模块，并配置全局中间件：

// app.js const express = require('express'); const cors = require('cors'); const helmet = require('helmet'); require('dotenv').config(); // 导入路由 const authRoutes = require('./routes/authRoutes'); const postRoutes = require('./routes/postRoutes'); const commentRoutes = require('./routes/commentRoutes'); const app = express(); const PORT = process.env.PORT || 3000; // 全局中间件 app.use(helmet()); // 安全相关 HTTP 头 app.use(cors()); // 处理跨域请求 app.use(express.json()); // 解析 JSON 格式的请求体 app.use(express.urlencoded({ extended: true })); // 解析 URL-encoded 格式的请求体 // 简单的请求日志中间件 app.use((req, res, next) => { console.log(`${new Date().toISOString()} - ${req.method} ${req.url}`); next(); }); // 注册路由 app.use('/api/auth', authRoutes); app.use('/api/posts', postRoutes); app.use('/api/comments', commentRoutes); // 健康检查端点 app.get('/health', (req, res) => { res.json({ status: 'OK', timestamp: new Date().toISOString() }); }); // 404 处理 app.use((req, res) => { res.status(404).json({ error: '请求的资源不存在' }); }); // 全局错误处理中间件 app.use((err, req, res, next) => { console.error('全局错误捕获:', err.stack); res.status(500).json({ error: '服务器内部错误' }); }); // 启动服务器 app.listen(PORT, () => { console.log(`博客平台后端服务已启动，监听端口: ${PORT}`); console.log(`环境: ${process.env.NODE_ENV}`); });

4. 运行验证与 API 测试

完成核心代码后，需要验证服务是否正常运行，API 是否符合预期。

4.1 启动服务与基础检查

1. 在package.json的scripts部分添加启动命令，方便开发：

   "scripts": { "start": "node app.js", "dev": "nodemon app.js" }

2. 在终端运行开发命令：

   npm run dev

   如果看到博客平台后端服务已启动，监听端口: 3000的输出，说明服务启动成功。
3. 使用浏览器或curl命令测试健康检查端点：

   curl http://localhost:3000/health

   预期返回{"status":"OK","timestamp":"..."}。

4.2 使用 Postman 或 cURL 测试核心 API

我们以用户注册和文章创建为例，演示 API 测试流程。

测试用户注册 (POST /api/auth/register):

curl -X POST http://localhost:3000/api/auth/register \ -H "Content-Type: application/json" \ -d '{ "username": "testuser", "email": "test@example.com", "password": "MySecurePass123" }'

预期成功响应 (201 Created):

{ "message": "注册成功", "token": "eyJhbGciOiJIUzI1NiIs...很长的一串JWT令牌", "user": { "id": 1, "username": "testuser", "email": "test@example.com" } }

测试用户登录 (POST /api/auth/login):

curl -X POST http://localhost:3000/api/auth/login \ -H "Content-Type: application/json" \ -d '{ "username": "testuser", "password": "MySecurePass123" }'

登录成功后也会返回一个token，用于后续受保护 API 的访问。

测试创建文章 (POST /api/posts):首先，复制登录接口返回的token。

curl -X POST http://localhost:3000/api/posts \ -H "Content-Type: application/json" \ -H "Authorization: Bearer <你的JWT令牌>" \ -d '{ "title": "我的第一篇博客", "content": "这是博客的详细内容...", "excerpt": "这是一个摘要" }'

预期成功响应 (201 Created):

{ "message": "文章创建成功", "postId": 1 }

测试获取文章列表 (GET /api/posts):

curl http://localhost:3000/api/posts

此接口为公开接口，无需令牌，应返回文章列表的 JSON 数据。

4.3 验证数据库状态

在 MySQL 客户端中查询数据，确认操作已持久化：

USE blog_platform; SELECT * FROM users; SELECT id, title, author_id FROM posts;

5. 常见问题排查与调试

在开发过程中，你可能会遇到以下典型问题。这里提供排查思路和解决方案。

5.1 数据库连接失败

现象：启动服务时报错Access denied for user 'root'@'localhost'或ER_ACCESS_DENIED_ERROR。排查步骤：

1. 检查.env文件：确认DB_PASSWORD等变量值是否正确，尤其注意特殊字符是否需要转义。
2. 验证 MySQL 服务状态：确保 MySQL 服务正在运行。
3. 测试命令行连接：使用mysql -u root -p输入密码，看是否能成功连接。
4. 检查用户权限：确认用于连接的数据库用户（如root）是否有权访问blog_platform数据库。

   GRANT ALL PRIVILEGES ON blog_platform.* TO 'root'@'localhost'; FLUSH PRIVILEGES;

5.2 请求体解析失败

现象：POST 请求中，控制器里的req.body是undefined。排查步骤：

1. 检查中间件顺序：确保app.use(express.json())和app.use(express.urlencoded(...))在路由注册之前。
2. 检查请求头：使用 Postman 或 curl 时，确认Content-Type: application/json已正确设置。
3. 检查数据格式：确保发送的 JSON 数据是有效的，没有尾随逗号或格式错误。

5.3 JWT 认证失败

现象：访问/api/auth/me或/api/posts（POST）时返回401 Unauthorized。排查步骤：

1. 检查令牌格式：确认请求头是Authorization: Bearer <token>，注意Bearer后面有一个空格。
2. 检查令牌有效期：令牌可能已过期。尝试重新登录获取新令牌。
3. 检查 JWT 密钥：确保.env文件中的JWT_SECRET与生成令牌时使用的密钥一致，且没有意外更改。
4. 验证令牌内容：可以临时在中间件中打印decoded对象，或使用在线工具（如 jwt.io）解码令牌，查看其 payload 内容是否正确。

5.4 跨域问题（CORS）

现象：前端应用调用 API 时，浏览器控制台报错CORS policy。排查步骤：

1. 已配置cors中间件：确认app.js中已正确使用app.use(cors())。
2. 检查前端请求：确保前端请求的 Origin 头没有被错误地修改或覆盖。
3. 复杂请求：对于 PUT、DELETE 或带有自定义头的请求，属于“复杂请求”，浏览器会先发送 OPTIONS 预检请求。确保后端能正确处理 OPTIONS 请求（cors()中间件通常已处理）。

5.5 异步操作未处理 Promise 拒绝

现象：服务器无响应或崩溃，控制台出现UnhandledPromiseRejectionWarning。排查步骤：

1. 检查所有异步调用：确保所有async函数中的await操作都包裹在try...catch中，或在链式调用末尾有.catch()处理。
2. 全局错误处理：确认app.js中已注册全局错误处理中间件（app.use((err, req, res, next) => {...})），它能捕获路由中未处理的错误。
3. 数据库查询错误：检查 Model 层中的 SQL 语句和参数是否正确，表名、列名是否有拼写错误。

下表总结了开发阶段常见问题及快速处理建议：

6. 从开发到生产：最佳实践与扩展方向

一个合格的毕业设计或项目，不能仅仅满足于在本地跑通。你需要考虑代码质量、安全性和可维护性。

6.1 代码结构与工程化建议

• 环境配置分离：严格区分开发、测试、生产环境。可以创建.env.development,.env.production文件，并通过NODE_ENV变量加载对应的配置。
• 输入验证与清理：在所有接收用户输入的接口（注册、登录、发布文章）中，必须进行验证。可以使用Joi或express-validator库。

  npm install express-validator

  // 在控制器或路由中使用 const { body, validationResult } = require('express-validator'); router.post('/register', [ body('username').isLength({ min: 3 }).trim().escape(), body('email').isEmail().normalizeEmail(), body('password').isLength({ min: 6 }) ], authController.register );

• 集中式错误处理：我们已经有了全局错误中间件，可以进一步扩展，根据错误类型（如数据库唯一键冲突、验证错误）返回更具体的 HTTP 状态码和消息。
• 日志记录：不要只使用console.log。在生产环境中，应使用winston或pino等日志库，将日志按级别（info, warn, error）输出到文件或日志服务。
• API 文档：使用swagger-jsdoc和swagger-ui-express自动生成 API 文档，这对于项目演示和后期维护非常重要。

6.2 安全性加固

• 密码存储：务必使用bcrypt等加盐哈希算法存储密码，绝对不要明文存储。
• SQL 注入防护：始终使用参数化查询（如?占位符）或预处理语句（Prepared Statements）。我们使用的mysql2的execute方法默认支持参数化查询，这已能有效防止 SQL 注入。
• HTTPS：在生产环境，必须通过 Nginx 或负载均衡器启用 HTTPS，或使用express的spdy/https模块。
• 速率限制：对登录、注册等接口实施速率限制，防止暴力破解。可以使用express-rate-limit中间件。
• 依赖安全：定期运行npm audit检查并修复依赖中的已知安全漏洞。

6.3 性能与扩展考虑

• 数据库连接池：我们已经使用了createPool，这比每次查询都创建新连接高效得多。连接池大小（connectionLimit）需要根据实际负载调整。
• 索引优化：为经常用于查询条件的列（如users.username,posts.author_id,comments.post_id）创建数据库索引，可以极大提升查询速度。
• API 分页：对于文章列表、评论列表等接口，务必实现分页（如limit和offset），避免一次性返回大量数据。
• 静态文件服务：如果博客有上传图片功能，应使用express.static中间件来提供静态文件访问，并考虑使用云存储（如 AWS S3、阿里云 OSS）来减轻服务器负担。

6.4 毕业设计文档与源码整合

对于毕业设计，除了可运行的程序，清晰的文档和代码结构同样重要。

• 开题报告：在本文的技术方案基础上，补充项目背景、研究意义、国内外现状、可行性分析、进度安排等内容。
• 任务书与中期报告：将开发过程分解为多个阶段任务（如环境搭建、数据库设计、核心模块开发、测试与部署），并在中期报告中汇报已完成部分和遇到的问题。
• 源码说明：在项目根目录提供清晰的README.md，说明如何安装依赖、配置环境、运行项目以及测试 API。
• 数据库设计文档：提供完整的 E-R 图和数据字典，解释每张表、每个字段的作用和关系。

通过以上步骤，你不仅得到了一个功能完整的 Express 博客平台后端，更掌握了一套从设计、编码、调试到优化的完整 Web 后端开发工作流。这个项目骨架清晰，模块职责分明，你可以在此基础上轻松扩展分类管理、标签系统、文章搜索、用户关注等更多功能，使其成为一个丰满的毕业设计作品。