Express/Koa/NestJS 等 Node.js 框架的中间件 (Middleware) 机制是什么？如何实现一个自定义中间件？ - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

大家好，我是你们今天的 Node.js 中间件老司机，今天咱们来聊聊 Express、Koa 和 NestJS 这些框架里神秘又强大的中间件机制。放心，我保证不让你打瞌睡，咱用最通俗的语言，配上实战代码，让你彻底搞懂中间件的精髓。

开场白：中间件，你身边的超级英雄

想象一下，你是一家餐厅的服务员，客人点了份意大利面。正常流程是：

你记录客人的订单。
你把订单交给厨房。
厨房做好意大利面。
你把意大利面端给客人。

现在，假设你餐厅来了个挑剔的客人，要求在意大利面上撒点额外的帕尔马干酪。如果没有中间件，你就得修改原始流程：

你记录客人的订单。
你检查订单是否需要帕尔马干酪。
如果需要，你从冰箱里拿出帕尔马干酪。
你把订单交给厨房，并告诉他们要加帕尔马干酪。
厨房做好意大利面。
你检查是否加了帕尔马干酪。
你把意大利面端给客人。

看到了吗？为了一个特殊的客人，你不得不修改整个流程，这太麻烦了！

这时候，中间件就闪亮登场了。你可以安排一个专门负责撒帕尔马干酪的“帕尔马干酪专员”，他负责在意大利面做好后，端给客人前，检查是否需要撒帕尔马干酪，并完成这个任务。

这个“帕尔马干酪专员”就是中间件！它拦截请求，做一些处理，然后决定是否继续传递给下一个环节。

什么是中间件？

简单来说，中间件就是在请求到达最终处理程序之前，或者在响应发送给客户端之前，执行的一段代码。它可以：

修改请求对象 (request)。
修改响应对象 (response)。
终止请求-响应循环。
调用链中的下一个中间件。
做任何你想做的事情！

不同框架的中间件机制

虽然都是中间件，但 Express、Koa 和 NestJS 的实现方式略有不同，我们逐个击破：

1. Express 的中间件

Express 的中间件是最经典的，也是很多 Node.js 开发者最早接触的中间件形式。

形式： Express 的中间件是一个函数，接收三个参数：req (request 对象), res (response 对象), 和 next (一个函数，用于传递到下一个中间件)。
类型：
- 应用级中间件: 绑定到 app 对象，作用于所有路由。
- 路由级中间件: 绑定到 router 实例，作用于特定路由。
- 错误处理中间件: 用于处理错误，接收四个参数：err (错误对象), req, res, next。
- 第三方中间件: 由社区提供的，例如 body-parser 用于解析请求体。

示例：

const express = require('express');
const app = express();

// 应用级中间件 - 日志记录
app.use((req, res, next) => {
  console.log(`[${new Date().toISOString()}] ${req.method} ${req.url}`);
  next(); // 必须调用 next()，否则请求会被阻塞
});

// 路由级中间件 - 验证用户是否登录
const requireLogin = (req, res, next) => {
  if (req.headers.authorization === 'Bearer valid_token') {
    next(); // 验证通过，继续处理
  } else {
    res.status(401).send('Unauthorized'); // 未授权，返回 401
  }
};

app.get('/profile', requireLogin, (req, res) => {
  res.send('Welcome to your profile!');
});

// 错误处理中间件 - 处理所有路由中的错误
app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).send('Something broke!');
});

app.listen(3000, () => {
  console.log('Server listening on port 3000');
});

app.use() 用于注册应用级中间件。
requireLogin 是一个路由级中间件，只有通过验证的用户才能访问 /profile 路由。
错误处理中间件必须在所有路由处理程序之后定义。

优点： 简单易懂，使用广泛，生态系统庞大。
缺点： next() 的使用容易出错，如果忘记调用 next()，请求就会卡住。

2. Koa 的中间件

Koa 是由 Express 团队打造的下一代 Node.js 框架，它使用了 ES6 的 async/await，让中间件的编写更加优雅。

形式： Koa 的中间件是一个 async 函数，接收两个参数：ctx (context 对象，包含了 req 和 res), 和 next (一个函数，用于传递到下一个中间件)。
洋葱模型： Koa 的中间件执行顺序就像洋葱一样，请求先经过外层中间件，然后一层一层地进入，到达路由处理程序，响应再一层一层地返回。

示例：

const Koa = require('koa');
const app = new Koa();

// 中间件 1 - 日志记录
app.use(async (ctx, next) => {
  console.log(`[${new Date().toISOString()}] ${ctx.method} ${ctx.url}`);
  await next(); // 必须 await next()，确保后续中间件执行完毕
});

// 中间件 2 - 验证用户是否登录
const requireLogin = async (ctx, next) => {
  if (ctx.headers.authorization === 'Bearer valid_token') {
    await next();
  } else {
    ctx.status = 401;
    ctx.body = 'Unauthorized';
  }
};

app.use(requireLogin);

// 路由处理程序
app.use(async ctx => {
  ctx.body = 'Welcome to your profile!';
});

app.listen(3000, () => {
  console.log('Server listening on port 3000');
});

app.use() 用于注册中间件。
ctx 对象包含了请求和响应的信息，方便操作。
await next() 确保后续中间件执行完毕，避免了 Express 中忘记调用 next() 的问题。

优点： 使用 async/await，代码更简洁，错误处理更方便，洋葱模型更容易理解中间件的执行顺序。
缺点： 学习曲线比 Express 稍高，需要熟悉 async/await。

3. NestJS 的中间件

NestJS 是一个用于构建高效、可伸缩的 Node.js 服务器端应用程序的框架。它使用了 TypeScript，并借鉴了 Angular 的一些设计理念。

形式： NestJS 的中间件是一个类，需要实现 NestMiddleware 接口。
注册方式： 中间件需要在模块中注册，并指定作用的路由。

示例：

// logger.middleware.ts
import { Injectable, NestMiddleware } from '@nestjs/common';
import { Request, Response, NextFunction } from 'express';

@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: NextFunction) {
    console.log(`[${new Date().toISOString()}] ${req.method} ${req.originalUrl}`);
    next();
  }
}

// app.module.ts
import { Module, NestModule, MiddlewareConsumer } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { LoggerMiddleware } from './logger.middleware';

@Module({
  imports: [],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer
      .apply(LoggerMiddleware)
      .forRoutes('*'); // 应用于所有路由
  }
}

// app.controller.ts
import { Controller, Get } from '@nestjs/common';
import { AppService } from './app.service';

@Controller()
export class AppController {
  constructor(private readonly appService: AppService) {}

  @Get()
  getHello(): string {
    return this.appService.getHello();
  }
}

LoggerMiddleware 类实现了 NestMiddleware 接口，并定义了 use 方法。
AppModule 实现了 NestModule 接口，并在 configure 方法中注册了 LoggerMiddleware，并指定应用于所有路由 ('*')。
MiddlewareConsumer 提供了灵活的配置选项，可以指定中间件应用于特定的路由、控制器或方法。

优点： 使用 TypeScript，代码更健壮，可维护性更高，结构清晰，易于测试。
缺点： 学习曲线较高，需要熟悉 TypeScript 和 NestJS 的概念。

如何实现一个自定义中间件？

现在，我们来动手实现一个自定义中间件，以 Express 为例：

需求： 检查请求头中是否包含 X-Custom-Header，如果包含，则将其值添加到 req.customHeader 属性中。

const express = require('express');
const app = express();

// 自定义中间件
const customHeaderMiddleware = (req, res, next) => {
  const customHeader = req.headers['x-custom-header'];
  if (customHeader) {
    req.customHeader = customHeader;
    console.log(`Custom Header: ${customHeader}`);
  }
  next();
};

// 注册中间件
app.use(customHeaderMiddleware);

// 路由处理程序
app.get('/', (req, res) => {
  res.send(`Hello World! Custom Header: ${req.customHeader || 'Not Found'}`);
});

app.listen(3000, () => {
  console.log('Server listening on port 3000');
});

在这个例子中：

customHeaderMiddleware 函数接收 req, res, 和 next 参数。
它从请求头中获取 X-Custom-Header 的值。
如果存在该请求头，则将其值添加到 req.customHeader 属性中。
调用 next() 将请求传递给下一个中间件或路由处理程序。

不同框架的中间件对比

为了更清晰地了解不同框架中间件的差异，我们用表格来总结一下：

特性	Express	Koa	NestJS
参数	`req`, `res`, `next`	`ctx`, `next`	`req`, `res`, `next`
函数类型	普通函数	async 函数	类 (实现 `NestMiddleware` 接口)
`next()`	必须手动调用	使用 `await next()`	必须手动调用
错误处理	错误处理中间件	try…catch, `ctx.onerror`	异常过滤器
注册方式	`app.use()`, `router.use()`	`app.use()`	模块配置 (使用 `MiddlewareConsumer`)
类型支持	JavaScript	JavaScript	TypeScript
核心概念	路由, 中间件, 请求/响应	Context, 洋葱模型, async/await	模块, 控制器, 提供者, 中间件, 依赖注入

中间件的最佳实践

保持中间件的职责单一： 一个中间件只负责一个特定的任务，例如日志记录、身份验证、数据验证等。
避免在中间件中进行复杂的业务逻辑： 复杂的业务逻辑应该放在服务层或模型层。
合理安排中间件的顺序： 顺序很重要，例如身份验证中间件应该放在路由处理程序之前。
正确处理错误： 在中间件中捕获错误，并将其传递给错误处理中间件。
使用第三方中间件： 充分利用社区提供的中间件，例如 body-parser, cors, helmet 等。

总结

中间件是 Node.js 框架中非常重要的一个概念，它可以帮助我们更好地组织代码，提高代码的可重用性和可维护性。Express、Koa 和 NestJS 都提供了强大的中间件机制，选择哪个框架取决于你的项目需求和个人偏好。

希望今天的讲座能让你对 Node.js 中间件有更深入的了解。记住，中间件就像你身边的超级英雄，总能在关键时刻挺身而出，解决你的难题！下次见！

发表回复 取消回复

发表回复取消回复