Edit: NodeJs“全栈之旅“正式启程（下）

标题 *

URL 别名 *

内容 * (支持 Markdown 格式)

### **第 14 节：数据库集成（MongoDB & Mongoose) — 让你的应用有‘记忆’！**

**好了，同学们，前面咱们的用户管理系统，数据都存在一个数组里，服务器一重启，数据就没了！** 这种“临时记忆”的应用可不行，咱们得给它一个“永久记忆”的大脑——**数据库**！

今天，咱们要学习如何将 Node.js 应用与一个非常流行的 NoSQL 数据库——**MongoDB** 连接起来，并使用一个超级好用的 ODM (Object Data Modeling) 库——**Mongoose**，来轻松地操作数据！

---

#### **14.1 NoSQL 数据库简介：MongoDB — 数据库界的‘自由派’！**

在传统的数据库世界里，我们经常听到**关系型数据库**（Relational Database，比如 MySQL, PostgreSQL, Oracle）。它们把数据存储在严格定义的表格里，就像 Excel 表格一样，每一行都是一条记录，每一列都有固定的类型，而且表格之间还有复杂的关联关系（用 SQL 语句操作）。

而 **NoSQL (Not only SQL)** 数据库，顾名思义，“不仅仅是 SQL”。它们提供了更灵活、更具扩展性的数据存储方式。**MongoDB** 就是其中一种最受欢迎的 **文档型 (Document-oriented)** NoSQL 数据库！

*   **数据存储：** MongoDB 将数据存储为 **BSON (Binary JSON)** 文档。啥是 BSON？就是二进制版的 JSON！你可以把它想象成跟 JavaScript 里的 JSON 对象几乎一模一样的数据结构！
*   **无模式 (Schema-less) 或灵活模式：** 这是 MongoDB 最吸引人的地方之一！在同一个集合 (Collection，你可以把它理解为关系型数据库里的“表”) 里，不同的文档（也就是记录）可以有不同的字段和结构，或者字段的顺序不一样，或者有些文档有这个字段，有些文档没有！这为开发提供了极大的灵活性，尤其是在数据结构不确定、经常变化，或者需要快速迭代产品时，简直是“神器”！当然，你也可以通过应用层面的工具（比如 Mongoose）来强制一些模式。
*   **可伸缩性：** MongoDB 非常容易进行水平扩展 (sharding)，也就是通过增加更多的服务器来分担负载，处理海量数据和高并发请求。
*   **高性能：** 它通常适用于大数据量和高并发场景。
*   **与 Node.js 的契合度：** 这点很重要！因为 MongoDB 使用 JSON 格式存储数据，而 Node.js 使用 JavaScript，JavaScript 天然就支持 JSON 对象！这使得 Node.js 开发者在操作 MongoDB 数据时，感觉就像在操作普通的 JavaScript 对象一样，几乎没有“转换成本”，非常自然和流畅！

---

#### **14.2 安装 MongoDB — 把‘记忆中心’建起来！**

安装 MongoDB 有多种方式，你可以根据自己的习惯和环境选择：

1.  **官方安装包：** 最直接的方式就是访问 MongoDB 官网下载，然后按照官方指南一步步安装适合你操作系统的版本。
    *   [MongoDB Community Edition Download](https://www.mongodb.com/try/download/community)
2.  **Docker：** **对于开发环境，强烈推荐使用 Docker！** 简直是“神器”！你只需要几行命令，就能把 MongoDB 跑在一个独立的容器里，不污染你本地的开发环境，而且启动停止都非常方便。
    ```bash
    # 1. 拉取 MongoDB 镜像 (第一次会下载，以后就很快了)
    docker pull mongo

# 2. 运行一个 MongoDB 容器 (命名为 my-mongo，端口 27017 映射到本地 27017，后台运行)
    docker run --name my-mongo -p 27017:27017 -d mongo
    # docker run: 运行容器
    # --name my-mongo: 给容器起个名字叫 my-mongo
    # -p 27017:27017: 把容器的 27017 端口映射到你本地的 27017 端口
    # -d mongo: 在后台运行 mongo 镜像
    ```
    *   **常用 Docker 命令：**
        *   `docker ps`: 查看正在运行的容器
        *   `docker stop my-mongo`: 停止容器
        *   `docker start my-mongo`: 启动容器
        *   `docker rm my-mongo`: 删除容器 (需要先停止)
        *   `docker logs my-mongo`: 查看容器日志
3.  **云服务：** 在生产环境中，咱们通常不会自己部署和维护数据库。而是会使用专业的云数据库服务，比如 **MongoDB Atlas** (MongoDB 官方提供的云数据库服务)，或者 AWS、Google Cloud、Azure 等云提供商的 MongoDB 服务。它们帮你搞定了高可用、备份、扩容等一系列复杂的运维工作。

**安装完成后，请务必确保 MongoDB 服务正在运行！** 默认情况下，MongoDB 运行在 `localhost:27017` 这个地址和端口上。

---

#### **14.3 使用 Mongoose ODM (Object Data Modeling) 连接 MongoDB — 你的‘超级翻译官’！**

直接使用 MongoDB 的原生驱动程序来操作数据库可能会有点“裸奔”和繁琐。这时候，咱们就需要一个“超级翻译官”兼“数据守护者”——**Mongoose**！

**Mongoose** 是一个流行的 Node.js **ODM (Object Data Modeling)** 库。它在 MongoDB 驱动程序之上提供了一个更高级别的抽象，使得与 MongoDB 的交互更加简单、结构化，而且还提供了强大的**模式验证**（Schema Validation）功能！这就像给灵活的 MongoDB 加上了“软约束”，确保你存入的数据符合你应用程序的预期。

**安装 Mongoose：**

```bash
npm install mongoose
```

**连接 MongoDB（非常简单！）：**

咱们通常会把数据库连接的代码单独放在一个文件里，方便管理。

```javascript
// db.js (在你项目的根目录创建一个 db.js 文件)
const mongoose = require('mongoose');

module.exports = connectDB; // 导出这个连接函数
```

**在 Express 应用中使用 `connectDB()`：**

你需要在你的 Express 应用启动之前，调用这个 `connectDB()` 函数。

```javascript
// app.js (你的 Express 应用主文件)
const express = require('express');
const connectDB = require('./db'); // 引入咱们刚刚写的数据库连接函数

const app = express();
const PORT = 3000;

// 启用 Express 内置的 JSON 解析中间件，非常重要，用于解析客户端发送的 JSON 请求体
app.use(express.json());

// 连接数据库！确保在你的路由和业务逻辑之前连接成功
connectDB();

// ... (这里将是你所有的 Express 路由和中间件代码)

app.get('/', (req, res) => {
    res.send('Welcome to Node.js & MongoDB App!');
});

app.listen(PORT, () => {
  console.log(`Express 服务器运行在 http://localhost:${PORT}`);
  console.log('请确保 MongoDB 服务正在运行在 localhost:27017，并且数据库名称为 mydatabase。');
});
```

**测试连接：**

1.  确保你的 MongoDB 服务已经启动并运行在 `localhost:27017`。
2.  保存 `db.js` 和 `app.js` 文件。
3.  在终端中运行 `node app.js`。
4.  如果你看到控制台输出 `MongoDB 连接成功: localhost`，那就说明你的 Node.js 应用已经成功连接到 MongoDB 数据库了！如果报错，请检查 MongoDB 服务是否启动，或者连接 URI 是否正确。

---

#### **14.4 Mongoose Schema 和 Model 的定义 — 数据的‘蓝图’和‘操作接口’！**

好了，数据库连上了，那怎么往里面存数据呢？难道随便存吗？

虽然 MongoDB 是“无模式”的，但咱们写应用程序可不能乱来！你需要对要存储的数据有一个“预期”，比如用户应该有哪些字段，它们的类型是什么，有没有必填项等等。Mongoose 的 **Schema (模式)** 和 **Model (模型)** 就是用来干这个的！

**1. Schema (模式) — 数据的‘蓝图’或者‘身份证’！**
*   Schema 定义了 MongoDB 文档的**结构**、每个字段的**数据类型**、**验证规则**和**默认值**。
*   它不是数据库中的实际“表结构”（MongoDB 没有“表”的概念），而是 Mongoose 在应用程序层面对你数据的一种“软约束”和“描述”。它保证了你通过 Mongoose 插入或更新的数据符合你定义的规则。

**2. Model (模型) — 数据的‘操作接口’或者‘特种兵小队’！**
*   Model 是 Schema 的“编译版本”。它是一个构造函数，你可以用它来创建新的文档实例。
*   更重要的是，它提供了与数据库交互的各种方法（比如 `find()`, `save()`, `update()`, `findByIdAndDelete()` 等等），让你能够方便地进行 CRUD 操作。

**示例：定义一个用户 Schema 和 Model**

咱们来为用户数据定义一个 Schema 和 Model。通常这些定义会放在一个单独的 `models` 文件夹里。

```javascript
// models/User.js (在你项目的根目录创建一个 models 文件夹，然后在里面创建 User.js 文件)
const mongoose = require('mongoose');

// 定义用户 Schema (数据的蓝图！)
const UserSchema = new mongoose.Schema({
  name: { // 用户名
    type: String, // 类型是字符串
    required: [true, '用户名是必填项'], // 必填项，如果没填就报错，并提供错误消息
    trim: true, // 自动去除字符串两端的空白字符
    minlength: [3, '用户名至少需要3个字符'] // 最小长度验证
  },
  email: { // 邮箱
    type: String,
    required: [true, '邮箱是必填项'],
    unique: true, // 邮箱必须是唯一的！如果重复插入会报错
    lowercase: true, // 存储前自动转换为小写（方便搜索和避免重复）
    match: [/.+@.+\..+/, '请输入有效的邮箱地址'] // 使用正则表达式验证邮箱格式
  },
  age: { // 年龄
    type: Number, // 类型是数字
    min: [0, '年龄不能为负数'], // 最小值验证
    max: [120, '年龄不能超过120'] // 最大值验证
  },
  createdAt: { // 创建时间
    type: Date, // 类型是日期
    default: Date.now // 默认值为当前时间，如果没有提供，就自动填上
  }
});

// 创建并导出 User Model (数据的操作接口！)
// 'User' 是集合的名称。Mongoose 会自动将其转换为小写并复数化，所以实际在 MongoDB 中会看到一个名为 'users' 的集合。
module.exports = mongoose.model('User', UserSchema);
```

**小提示：** 在上面的 `UserSchema` 中，我们定义了各种验证规则（`required`, `unique`, `minlength`, `match` 等）。这些验证会在你尝试保存数据到数据库时自动执行。如果验证失败，Mongoose 会抛出 `ValidationError`，你可以捕获它并返回给客户端。

---

#### **14.5 基本 CRUD (创建、读取、更新、删除) 操作 — 让你的应用学会‘增删改查’！**

好了，数据库连上了，Model 也定义好了，现在咱们就来把之前那个“临时记忆”的用户管理系统，升级成一个能真正把数据存起来的 RESTful API！我们将把 Mongoose 的操作集成到 Express.js 路由中。

```javascript
// app.js (一个相对完整的 Express 应用示例)

const express = require('express');
const connectDB = require('./db');      // 引入数据库连接函数
const User = require('./models/User');  // 引入 User 模型

const app = express();
const PORT = 3000;

// 连接数据库 (确保在路由定义之前连接成功)
connectDB();

// --- 中间件 ---
// 启用 Express 内置的 JSON 解析中间件，用于解析客户端发送的 JSON 请求体
app.use(express.json());
// 启用 Express 内置的 URL-encoded 解析中间件
app.use(express.urlencoded({ extended: true }));

// --- RESTful 用户 API 路由 ---

// GET /api/users - 获取所有用户
app.get('/api/users', async (req, res) => {
  try {
    const users = await User.find(); // 使用 User Model 的 find() 方法查找所有用户
    res.status(200).json(users); // 返回 200 OK 和用户列表
  } catch (err) {
    // 错误处理：通常返回 500 Internal Server Error
    console.error('获取用户失败:', err.message);
    res.status(500).json({ message: '获取用户失败', error: err.message });
  }
});

// GET /api/users/:id - 获取单个用户
app.get('/api/users/:id', async (req, res) => {
  try {
    const user = await User.findById(req.params.id); // 使用 findById() 根据 ID 查找用户
    if (!user) {
      return res.status(404).json({ message: '用户未找到' }); // 如果没找到，返回 404 Not Found
    }
    res.status(200).json(user); // 返回 200 OK 和用户数据
  } catch (err) {
    // 错误处理：比如 ID 格式不正确，Mongoose 会抛出 CastError
    if (err.name === 'CastError') {
      return res.status(400).json({ message: '无效的用户 ID 格式' }); // 400 Bad Request
    }
    console.error('获取单个用户失败:', err.message);
    res.status(500).json({ message: '获取用户失败', error: err.message });
  }
});

// POST /api/users - 创建新用户
app.post('/api/users', async (req, res) => {
  const { name, email, age } = req.body;
  // 创建一个新的 User 文档实例 (注意这里还没有保存到数据库，只是内存中的一个对象)
  const newUser = new User({ name, email, age });

try {
    const savedUser = await newUser.save(); // 使用 save() 方法将新用户保存到数据库
    res.status(201).json(savedUser); // 返回 201 Created 和创建成功的用户数据
  } catch (err) {
    // 错误处理：Mongoose 验证错误或唯一性错误
    if (err.name === 'ValidationError') { // 如果数据不符合 Schema 验证规则
      const errors = Object.values(err.errors).map(el => el.message); // 提取所有验证错误信息
      return res.status(400).json({ message: '数据验证失败', errors: errors }); // 返回 400 Bad Request
    }
    if (err.code === 11000) { // 如果是 MongoDB 的唯一性约束错误 (例如邮箱重复)
      return res.status(409).json({ message: '邮箱已被注册，请使用其他邮箱', field: 'email' }); // 409 Conflict
    }
    console.error('创建用户失败:', err.message);
    res.status(500).json({ message: '服务器内部错误', error: err.message });
  }
});

// PUT /api/users/:id - 更新用户 (完全替换)
app.put('/api/users/:id', async (req, res) => {
  try {
    // findByIdAndUpdate 根据 ID 查找并更新文档
    // 第一个参数是 ID
    // 第二个参数是更新的数据
    // { new: true }：返回更新后的文档（默认返回更新前的）
    // { runValidators: true }：确保在更新时也运行 Schema 中定义的验证规则
    const updatedUser = await User.findByIdAndUpdate(
      req.params.id,
      req.body,
      { new: true, runValidators: true }
    );

if (!updatedUser) {
      return res.status(404).json({ message: '用户未找到' });
    }
    res.status(200).json(updatedUser);
  } catch (err) {
    // 错误处理同上
    if (err.name === 'CastError') {
      return res.status(400).json({ message: '无效的用户 ID 格式' });
    }
    if (err.name === 'ValidationError') {
      const errors = Object.values(err.errors).map(el => el.message);
      return res.status(400).json({ message: '数据验证失败', errors: errors });
    }
    if (err.code === 11000) {
      return res.status(409).json({ message: '邮箱已被注册，请使用其他邮箱' });
    }
    console.error('更新用户失败:', err.message);
    res.status(500).json({ message: '服务器内部错误', error: err.message });
  }
});

// DELETE /api/users/:id - 删除用户
app.delete('/api/users/:id', async (req, res) => {
  try {
    const deletedUser = await User.findByIdAndDelete(req.params.id); // 根据 ID 查找并删除文档
    if (!deletedUser) {
      return res.status(404).json({ message: '用户未找到' });
    }
    res.status(204).send(); // 204 No Content: 表示请求成功，但没有返回任何内容
  } catch (err) {
    if (err.name === 'CastError') {
      return res.status(400).json({ message: '无效的用户 ID 格式' });
    }
    console.error('删除用户失败:', err.message);
    res.status(500).json({ message: '服务器内部错误', error: err.message });
  }
});

// 启动服务器
app.listen(PORT, () => {
  console.log(`Express 服务器运行在 http://localhost:${PORT}`);
  console.log('请确保 MongoDB 服务正在运行在 localhost:27017，并且数据库名称为 mydatabase！');
  console.log('\n使用 Postman/Insomnia 或 curl 命令测试这些 API:');
  console.log('  GET    /api/users');
  console.log('  POST   /api/users (Body: {"name": "John Doe", "email": "john@example.com", "age": 30})');
  console.log('  GET    /api/users/:id'); // 使用 POST 返回的 ID
  console.log('  PUT    /api/users/:id (Body: {"name": "Jane Doe", "email": "jane.d@example.com"})');
  console.log('  DELETE /api/users/:id');
});

// --- 全局错误处理中间件 (放在所有路由和常规中间件之后) ---
// 它会捕获所有未被前面 try...catch 捕获的错误，或者通过 next(err) 传递过来的错误
app.use((err, req, res, next) => {
  console.error('未捕获的错误或内部错误:', err.stack); // 打印错误堆栈到服务器控制台
  const statusCode = err.statusCode || 500; // 如果错误有自定义状态码，就用它，否则默认为 500
  res.status(statusCode).json({
    status: 'error',
    message: err.message || '服务器内部错误，请稍后再试。'
    // 在开发环境中，你可以考虑暴露更多错误信息，生产环境不要！
    // stack: process.env.NODE_ENV === 'development' ? err.stack : undefined
  });
});
```

**运行步骤：**

1.  **确保 MongoDB 服务正在运行！** (如果你用 Docker，执行 `docker start my-mongo`)
2.  在你项目的根目录，确保你已经执行了 `npm init -y`。
3.  安装必要的依赖：`npm install express mongoose`
4.  创建 `db.js` 文件，并粘贴咱们前面讲的 MongoDB 连接代码。
5.  创建 `models` 文件夹，然后在里面创建 `User.js` 文件，并粘贴咱们前面讲的 Mongoose Schema 和 Model 定义代码。
6.  创建 `app.js` 文件，并粘贴上面完整的 Express 应用代码。
7.  在终端中运行 `node app.js`。
8.  使用 Postman、Insomnia 或者 `curl` 命令来测试这些 API！

**测试示例：**

*   **创建用户 (POST `http://localhost:3000/api/users`)**
    *   Body (raw, JSON):
        ```json
        {
          "name": "测试用户",
          "email": "test@example.com",
          "age": 28
        }
        ```
    *   响应应该是一个 201 Created 状态码，并返回创建成功的用户数据，里面会有一个 `_id` 字段（MongoDB 自动生成的唯一 ID），记住这个 ID！

*   **获取所有用户 (GET `http://localhost:3000/api/users`)**
    *   你会看到你刚刚创建的用户。

*   **获取单个用户 (GET `http://localhost:3000/api/users/<刚刚记住的ID>`)**
    *   比如：`http://localhost:3000/api/users/60d5ec49f8e7c20015f8e7c2d`

*   **更新用户 (PUT `http://localhost:3000/api/users/<要更新的ID>`)**
    *   Body (raw, JSON):
        ```json
        {
          "name": "更新后的测试用户",
          "email": "updated_test@example.com",
          "age": 30
        }
        ```

*   **删除用户 (DELETE `http://localhost:3000/api/users/<要删除的ID>`)**
    *   如果删除成功，会返回 204 No Content 状态码，没有响应体。

---

**本节总结：**

好了，同学们，通过本节的学习，你已经：

*   深入理解了 Express.js 中间件的各种类型（应用级、路由级、错误处理），并学会了如何编写自定义中间件来实现特定的功能。
*   认识并学会了使用 `morgan`、`cors`、`helmet`、`express-session` 等常用的第三方中间件，让你的 Express 应用更加强大和安全。
*   **最重要的是，你学会了如何将 Node.js 应用程序与 MongoDB 数据库集成，使用 Mongoose 进行数据建模（Schema 和 Model 的定义），并能够轻松地执行基本的 CRUD (创建、读取、更新、删除) 操作！**

你现在已经具备了构建一个功能完善、能够存储和管理数据的 Node.js 后端应用的能力了！这可是全栈开发中至关重要的一步！

**下节预告：**
数据有了，API 也有了，但是，用户怎么登录呢？怎么保护你的 API 不被随便访问呢？下节课，咱们就要学习用户认证与授权的核心机制——**JWT (JSON Web Token)**！让你的 API 变得“聪明”又“安全”！准备好了吗？咱们下节课，不见不散！

好的，同学们，欢迎回来！

上节课咱们搞定了 Express.js 的路由和请求处理，学会了从 URL 里“挖”数据，也能优雅地处理 POST 请求体，甚至还搭建了一个简单的 RESTful 用户管理 API。是不是感觉自己的 Web 开发能力又上了一个台阶？

今天，咱们要继续深入 Express.js 的“内功心法”——**中间件**！它可是 Express.js 最强大、最灵活的“武器”！同时，咱们还要正式把你的 Node.js 应用和**数据库**连接起来，让你的应用拥有“永久记忆”！没有数据库的应用，就像没有大脑的人，啥都记不住！

---

### **第 13 节：Express.js 中间件深入 — 你的 Web 应用‘变形金刚’！**

**学习目标：**
在本节课中，你将深入理解 Express.js 中间件的各种类型（应用级、路由级、错误处理），学会如何编写自定义中间件来实现特定的功能，并认识一些常用的第三方中间件，让你的 Express 应用变得更加强大、安全和易于管理。

---

#### **13.1 应用级中间件、路由级中间件、错误处理中间件 — 中间件的‘兵种分类’！**

**各位老铁，同学们好啊！** 还记得咱们在 Express.js 入门时，提到中间件就像流水线上的“工人”吗？实际上，这些“工人”还分不同的“兵种”和“级别”，它们在流水线上承担着不同的职责和作用范围。

1.  **应用级中间件 (Application-level Middleware):**
    *   **作用范围：** 这是最常见的中间件！使用 `app.use()` 或 `app.METHOD()` (比如 `app.app.get()`, `app.post()`) 绑定到 `app` 这个 Express 应用实例上。
    *   **执行时机：**
        *   如果使用 `app.use()` 且**没有指定路径**：那么这个中间件将应用于**所有**进入 Express 应用的请求（无论什么路径，什么 HTTP 方法）。它就像你公司门口的保安，每个进公司的人都要过他那关。
        *   如果使用 `app.use('/path', callback)`：这个中间件只应用于以该 `path` 开头的所有请求。比如 `app.use('/api', ...)`，那么只有 `api` 开头的请求才会经过它。
        *   `app.METHOD(path, callback)`：这些也是应用级中间件，只不过它们绑定到了特定的 HTTP 方法和路径。它们通常是请求处理链的**终点**（也就是处理完就直接响应了，不用 `next()` 了）。
    *   **示例：**
        ```javascript
        const express = require('express');
        const app = express();
        const PORT = 3000;

// 应用级中间件 1：对所有请求生效的日志记录器
        // 就像公司大门口的打卡机，每个人进来都要打卡
        app.use((req, res, next) => {
          console.log(`[应用级中间件] 收到请求: ${req.method} ${req.url} at ${new Date().toISOString()}`);
          next(); // 必须调用 next()，否则请求会在这里停止！
        });

// 应用级中间件 2：只对 /api 路径生效的中间件
        // 就像公司的“API 部门”的门禁，只有去 API 部门的人才需要刷卡
        app.use('/api', (req, res, next) => {
          console.log('[应用级中间件] 请求进入 /api 部门。');
          next();
        });

// 路由处理函数 (也是一种特殊的应用级中间件)
        app.get('/', (req, res) => {
          res.send('首页');
        });

app.get('/api/data', (req, res) => {
          res.json({ message: 'API 部门的数据' });
        });

app.listen(PORT, () => console.log(`服务器运行在 http://localhost:${PORT}`));
        ```

2.  **路由级中间件 (Router-level Middleware):**
    *   **作用范围：** 它不是直接绑定到 `app` 实例，而是绑定到 `express.Router()` 实例。你可以把 `express.Router()` 想象成 Express.js 应用里的小型“子应用程序”或者“模块化的路由器”。
    *   **目的：** 当你的应用变得庞大，路由逻辑复杂时，你可以把相关的路由和中间件组织到一个独立的路由模块里，提高代码的模块化和可维护性。
    *   **示例：**
        ```javascript
        // usersRoutes.js (一个新的文件，专门管理用户相关的路由和中间件)
        const express = require('express');
        const router = express.Router(); // 创建一个路由实例

// 路由级中间件：只对通过此 router 处理的请求生效
        // 就像“用户管理部门”的内部规定，只有进入这个部门的人才需要遵守
        router.use((req, res, next) => {
          console.log(`[路由级中间件] 请求到用户部门: ${req.method} ${req.url}`);
          next();
        });

router.get('/', (req, res) => {
          res.send('用户列表页');
        });

router.get('/:id', (req, res) => {
          res.send(`用户 ID: ${req.params.id}`);
        });

module.exports = router; // 导出这个路由实例

// app.js (在你的主应用里引入并使用这个路由模块)
        const express = require('express');
        const app = express();
        const usersRoutes = require('./usersRoutes'); // 引入用户路由模块
        const PORT = 3000;

// ... (其他应用级中间件，比如日志中间件)

// 将用户路由模块挂载到应用程序的 /users 路径下
        // 任何访问 /users/xx 的请求都会先经过 usersRoutes 里的中间件
        app.use('/users', usersRoutes);

app.get('/', (req, res) => res.send('首页'));

app.listen(PORT, () => console.log(`服务器运行在 http://localhost:${PORT}`));
        ```
        **测试：** 访问 `http://localhost:3000/users/123`，你会看到应用级和路由级中间件的日志都打印出来了。

3.  **错误处理中间件 (Error-handling Middleware):**
    *   **特点：** 这是最特殊的中间件！它有**四个参数**：`(err, req, res, next)`。其他中间件只有三个参数。
    *   **执行时机：** 它们必须定义在**所有其他路由和常规中间件的后面**！当你的任何路由或中间件中发生错误（例如，你调用了 `next(err)` 并传入一个错误对象）时，Express 会非常智能地跳过所有常规中间件，直接把控制权交给这个错误处理中间件！它就像你公司的“急诊室”，专门处理各种突发状况。
    *   **示例：**
        ```javascript
        const express = require('express');
        const app = express();
        const PORT = 3000;

// ... (省略常规中间件和路由)

app.get('/error-test', (req, res, next) => {
          // 模拟一个错误发生
          const error = new Error('这是一个测试错误！我故意抛出来的！');
          error.statusCode = 500; // 可以自定义错误属性，比如状态码
          next(error); // 将错误传递给下一个错误处理中间件
        });

// 404 处理中间件 (放在所有路由之后，错误处理之前)
        // 如果前面所有路由和中间件都没匹配到请求，就会走到这里
        app.use((req, res, next) => {
          res.status(404).send('<h1>404 Not Found</h1><p>您访问的页面不存在。</p>');
        });

// 错误处理中间件 (必须有四个参数：err, req, res, next)
        // 且必须放在所有路由和常规中间件的最后面！
        app.use((err, req, res, next) => {
          console.error('哎呀！捕获到错误了:', err.stack); // 打印错误堆栈到服务器控制台，方便调试
          const statusCode = err.statusCode || 500; // 如果错误有自定义状态码就用，否则默认为 500
          res.status(statusCode).send(`
            <h1>${statusCode} - 服务器出错了！</h1>
            <p>${err.message}</p>
            <pre>${process.env.NODE_ENV === 'development' ? err.stack : ''}</pre>
            <p>生产环境不会显示堆栈信息，怕泄露隐私！</p>
          `);
          // 注意：错误处理中间件里通常不需要调用 next()，因为它是处理请求的终点
        });

app.listen(PORT, () => console.log(`服务器运行在 http://localhost:${PORT}`));
        ```
        **测试：**
        *   访问 `http://localhost:3000/error-test`，你会看到自定义的错误页面。
        *   访问 `http://localhost:3000/nonexistent-path`，你会看到 404 页面。

---

#### **13.2 自定义中间件的编写 — 打造你自己的‘特种兵’！**

编写自定义中间件非常简单，你只需要定义一个函数，并确保它的参数是 `(req, res, next)` 就行了。然后，在这个函数里写你的业务逻辑，最后别忘了调用 `next()` 或发送响应来结束请求。

**示例：身份验证中间件**

这个中间件可以用来检查用户是否登录，或者是否有权限访问某个资源。

```javascript
// authMiddleware.js (一个新的文件，专门放你的自定义中间件)

function authenticate(req, res, next) {
  // 假设我们从请求头中获取一个 API Key 来进行简单认证
  const apiKey = req.headers['x-api-key'];

if (apiKey === 'MY_SECRET_API_KEY_123') { // 假设这是你的秘密 API Key
    // 认证成功！可以在 req 对象上添加用户信息，方便后续路由使用
    req.user = { id: 101, name: '认证用户_张三', role: 'admin' };
    console.log('[认证中间件] 认证成功！用户:', req.user.name);
    next(); // 认证通过，继续处理请求，交给下一个中间件或路由
  } else {
    // 认证失败！直接发送 401 Unauthorized 响应，并结束请求
    console.log('[认证中间件] 认证失败！无效的 API Key。');
    res.status(401).send('未授权: 请提供有效的 API Key！');
    // 这里没有调用 next()，因为已经发送了响应，请求流程结束
  }
}

module.exports = authenticate; // 导出这个中间件函数

// app.js (在你的主应用里使用这个自定义中间件)
const express = require('express');
const app = express();
const authenticate = require('./authMiddleware'); // 引入自定义中间件
const PORT = 3000;

app.use(express.json()); // 用于解析请求体

// 应用到所有以 /secure 开头的路径的请求
// 只有带了正确的 API Key 的请求才能进入 /secure 内部的路由
app.use('/secure', authenticate); // 放在 /secure 路由定义之前

// 受保护的路由
app.get('/secure/data', (req, res) => {
  // 只有通过 authenticate 中间件的请求才能到达这里
  res.json({ message: `欢迎, ${req.user.name}! 这是受保护的秘密数据。`, data: '这是只有 VIP 才能看的信息！' });
});

// 公开的路由，不需要认证
app.get('/public/data', (req, res) => {
  res.send('这是公开数据，无需认证，任何人都可以访问。');
});

app.listen(PORT, () => console.log(`服务器运行在 http://localhost:${PORT}`));
```
**测试：**
*   `GET http://localhost:3000/public/data` (成功)
*   `GET http://localhost:3000/secure/data` (你会得到 401 未授权错误，因为没带 API Key)
*   `GET http://localhost:3000/secure/data` (用 Postman 或 curl，添加请求头 `X-API-Key: MY_SECRET_API_KEY_123`，你会成功获取数据！)

---

#### **13.3 常用的第三方中间件介绍 — NPM 上的‘宝藏’！**

Express.js 的强大之处，很大一部分要归功于其庞大的中间件生态系统。NPM 上有无数的第三方中间件，它们帮你解决了各种常见的问题，让你不用“重复造轮子”。

这里介绍几个你在实际项目中肯定会用到的“明星中间件”：

1.  **`morgan` (HTTP 请求日志):**
    *   **作用：** 自动帮你记录 HTTP 请求的详细信息，比如请求方法、URL、状态码、响应时间等等。非常适合开发时调试和生产环境监控。
    *   **安装：** `npm install morgan`
    *   **使用：**
        ```javascript
        const morgan = require('morgan');
        // ...
        app.use(morgan('dev')); // 'dev' 是一种预定义的日志格式，它会输出简洁的带颜色的日志到控制台
        // 还有 'tiny', 'short', 'common', 'combined' 等多种格式
        // 你也可以自定义格式: app.use(morgan(':method :url :status :response-time ms - :res[content-length]'));
        ```
        运行后，每次请求都会在你的服务器控制台打印一行日志，清晰明了！

2.  **`cors` (跨域资源共享):**
    *   **作用：** 当你的前端应用和后端 API 不在同一个域名下时，就会遇到**跨域问题**（CORS 错误）。`cors` 中间件可以帮你轻松地设置 CORS 策略，允许或限制来自不同源的 Web 应用程序访问你的服务器资源。
    *   **安装：** `npm install cors`
    *   **使用：**
        ```javascript
        const cors = require('cors');
        // ...
        app.use(cors()); // 最简单粗暴的方式：允许所有来源的跨域请求 (开发环境常用，生产环境慎用！)

// 生产环境通常需要配置特定的来源，更安全：
        // app.use(cors({
        //   origin: 'http://your-frontend-domain.com', // 只允许来自这个域名的请求
        //   methods: ['GET', 'POST', 'PUT', 'DELETE'], // 允许的 HTTP 方法
        //   allowedHeaders: ['Content-Type', 'Authorization'] // 允许的请求头
        // }));
        ```

3.  **`helmet` (安全):**
    *   **作用：** “安全帽”中间件！它通过设置各种 HTTP 响应头，来帮助你的 Express 应用程序抵御一些常见的 Web 漏洞和攻击。比如 XSS (跨站脚本攻击)、Clickjacking (点击劫持) 等。
    *   **安装：** `npm install helmet`
    *   **使用：**
        ```javascript
        const helmet = require('helmet');
        // ...
        app.use(helmet()); // 启用所有默认的 Helmet 中间件（通常就够用了）
        // 你也可以选择性地启用或禁用其中的某些模块，比如：
        // app.use(helmet.contentSecurityPolicy()); // 内容安全策略
        // app.use(helmet.xssFilter()); // XSS 过滤
        ```

4.  **`express-session` (会话管理):**
    *   **作用：** 如果你不想用 JWT，或者需要传统的基于 Session 的会话管理，`express-session` 提供了强大的会话管理功能，允许你在用户请求之间存储用户特定的数据（比如用户是否登录，购物车里有啥）。
    *   **安装：** `npm install express-session`
    *   **使用：** (需要一个 `secret` 字符串来签名会话 ID 的 Cookie，这个 `secret` 必须保密！)
        ```javascript
        const session = require('express-session');
        // ...
        app.use(session({
          secret: 'your_secret_key_for_session_security', // 必须提供一个秘密字符串，用于签名会话 ID
          resave: false, // 强制会话保存，即使它在请求期间没有被修改（通常设置为 false）
          saveUninitialized: true, // 强制未初始化的会话保存到存储（通常设置为 true）
          cookie: { secure: false } // 在生产环境中，如果使用 HTTPS，应设置为 true！
        }));

app.get('/set-session', (req, res) => {
          // req.session 对象就是存储会话数据的地方
          req.session.views = (req.session.views || 0) + 1; // 统计访问次数
          res.send(`你访问了此页面 ${req.session.views} 次`);
        });
        ```