NestJS 中的中间件是什么？它与 guards/interceptors 有什么不同？

Question

Accepted Answer

**Middleware** 是在 **路由处理器之前** 运行的函数，可以访问 request 和 response 对象 — 这与 Express 中间件的概念相同。NestJS 还有 guards、interceptors、pipes 和 filters，每个都在请求生命周期的特定点运行，具有不同的目的。知道使用哪个是关键。

## Middleware — 首先运行，可访问 req/res

```ts
@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: NextFunction) {
    console.log(`${req.method} ${req.url}`);   // logging, modifying req
    next();                                      // MUST call next() to continue
  }
}

// register in a module
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer.apply(LoggerMiddleware).forRoutes("*");   // apply to routes
  }
}
```

Middleware 最早运行，在 guards/interceptors/pipes 之前，并使用原始 `req`/`res` 工作 — 适合日志记录、请求修改、CORS 和 Express 兼容的关注点。

## 完整的请求生命周期顺序

```text
Request →
  1. Middleware     (req/res; runs first, Express-style)
  2. Guards         (return true/false → AUTHORIZE or block the request)
  3. Interceptors   (BEFORE the handler)
  4. Pipes          (validate/transform the handler's arguments)
  5. → Route Handler ←
  6. Interceptors   (AFTER the handler — transform the response)
  7. Exception Filters (if an error was thrown anywhere)
→ Response
```

## 每个的用途（选择正确的工具）

```text
Middleware  → general pre-processing with req/res (logging, CORS, raw request work)
Guards      → AUTHORIZATION — decide if a request may proceed (auth, roles)
              (return true = allow, false/throw = block)
Interceptors→ wrap the handler — transform request/response, add logging/caching/timing
              (can run logic BEFORE and AFTER the handler)
Pipes       → VALIDATE/TRANSFORM the handler's input arguments (DTO validation)
Filters     → catch and format EXCEPTIONS into responses
```

关键区别：middleware 是通用的 Express 风格的预处理；**guards** 专门处理授权（这是处理 auth 的干净、专门的地方，不同于在 middleware 中塞入）；**interceptors** 包装处理器以转换响应或添加横切行为；**pipes** 验证输入；**filters** 处理错误。

## 何时使用 middleware vs guards vs interceptors

```text
Auth check?           → Guard (dedicated, has execution context, returns boolean)
Logging requests?     → Middleware OR an interceptor (interceptor sees the response too)
Transform responses?  → Interceptor (runs after the handler)
Validate a DTO?       → Pipe
Modify raw req early?  → Middleware
```

## 为什么这很重要

理解中间件及其与 guards、interceptors、pipes 和 filters 的区别对于正确构建 NestJS 应用至关重要 — 每个都有特定的角色并在请求生命周期的特定点运行，使用正确的工具可以编写干净、惯用的代码。

Middleware 使用原始 req/res 处理一般的 Express 风格预处理。

关键的区别是 **guards** 是处理授权（auth/roles）的专门、正确的地方 — 比在 middleware 中这样做要干净得多 — 而 **interceptors** 包装处理器以转换响应和添加横切关注点（日志记录、缓存、计时），这是 middleware 无法轻松做到的（因为它在处理器之前运行且无法自然地看到响应）。

知道完整的生命周期顺序（middleware → guards → interceptors → pipes → handler → interceptors → filters）以及哪个工具适合每个关注点（auth → guard、response transformation → interceptor、validation → pipe、errors → filter）是 NestJS 能力的标志，并防止了在所有地方滥用 middleware 的常见错误。

这是框架中经常测试的、架构上重要的主题。