Overview

中间件

学习如何在 NestJS 中创建和使用中间件来处理请求和响应

中间件是在路由处理程序之前调用的函数。中间件函数可以访问应用程序请求-响应周期中的请求和响应对象，以及 next() 中间件函数。next 中间件函数通常由名为 next 的变量表示。

Middlewares_1

默认情况下，Nest 中间件等同于 express 中间件。以下来自官方 express 文档的描述说明了中间件的功能：

中间件函数可以执行以下任务：

执行任何代码。

对请求和响应对象进行更改。

结束请求-响应周期。

调用堆栈中的下一个中间件函数。

如果当前中间件函数没有结束请求-响应周期，它必须调用 next() 将控制权传递给下一个中间件函数。否则，请求将被挂起。

您可以在函数中或在带有 @Injectable() 装饰器的类中实现自定义 Nest 中间件。类应该实现 NestMiddleware 接口，而函数没有任何特殊要求。让我们首先使用类方法实现一个简单的中间件功能。

warning 警告 Express 和 fastify 处理中间件的方式不同，并提供不同的方法签名，在此处阅读更多信息。

@@filename(logger.middleware)
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('Request...');
    next();
  }
}
@@switch
import { Injectable } from '@nestjs/common';

@Injectable()
export class LoggerMiddleware {
  use(req, res, next) {
    console.log('Request...');
    next();
  }
}

依赖注入

Nest 中间件完全支持依赖注入。就像提供者和控制器一样，它们能够注入依赖项，这些依赖项在同一模块内可用。像往常一样，这是通过 constructor 完成的。

应用中间件

在 @Module() 装饰器中没有中间件的位置。相反，我们使用模块类的 configure() 方法来设置它们。包含中间件的模块必须实现 NestModule 接口。让我们在 AppModule 级别设置 LoggerMiddleware。

@@filename(app.module)
import { Module, NestModule, MiddlewareConsumer } from '@nestjs/common';
import { LoggerMiddleware } from './common/middleware/logger.middleware';
import { CatsModule } from './cats/cats.module';

@Module({
  imports: [CatsModule],
})
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer
      .apply(LoggerMiddleware)
      .forRoutes('cats');
  }
}
@@switch
import { Module } from '@nestjs/common';
import { LoggerMiddleware } from './common/middleware/logger.middleware';
import { CatsModule } from './cats/cats.module';

@Module({
  imports: [CatsModule],
})
export class AppModule {
  configure(consumer) {
    consumer
      .apply(LoggerMiddleware)
      .forRoutes('cats');
  }
}

在上面的示例中，我们为之前在 CatsController 内定义的 /cats 路由处理程序设置了 LoggerMiddleware。我们还可以通过在配置中间件时向 forRoutes() 方法传递包含路由 path 和请求 method 的对象，进一步将中间件限制为特定的请求方法。在下面的示例中，请注意我们导入了 RequestMethod 枚举来引用所需的请求方法类型。

@@filename(app.module)
import { Module, NestModule, RequestMethod, MiddlewareConsumer } from '@nestjs/common';
import { LoggerMiddleware } from './common/middleware/logger.middleware';
import { CatsModule } from './cats/cats.module';

@Module({
  imports: [CatsModule],
})
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer
      .apply(LoggerMiddleware)
      .forRoutes({ path: 'cats', method: RequestMethod.GET });
  }
}
@@switch
import { Module, RequestMethod } from '@nestjs/common';
import { LoggerMiddleware } from './common/middleware/logger.middleware';
import { CatsModule } from './cats/cats.module';

@Module({
  imports: [CatsModule],
})
export class AppModule {
  configure(consumer) {
    consumer
      .apply(LoggerMiddleware)
      .forRoutes({ path: 'cats', method: RequestMethod.GET });
  }
}

info 提示 configure() 方法可以使用 async/await 变为异步（例如，您可以在 configure() 方法体内 await 异步操作的完成）。

warning 警告使用 express 适配器时，NestJS 应用程序默认会从 body-parser 包注册 json 和 urlencoded。这意味着如果您想通过 MiddlewareConsumer 自定义该中间件，您需要在使用 NestFactory.create() 创建应用程序时将 bodyParser 标志设置为 false 来关闭全局中间件。

路由通配符

NestJS 中间件也支持基于模式的路由。例如，命名通配符（*splat）可以用作通配符来匹配路由中字符的任何组合。在以下示例中，中间件将对任何以 abcd/ 开头的路由执行，无论后面跟多少个字符。

forRoutes({
  path: 'abcd/*splat',
  method: RequestMethod.ALL,
});

info 提示 splat 只是通配符参数的名称，没有特殊含义。您可以将其命名为任何您喜欢的名称，例如 *wildcard。

'abcd/*' 路由路径将匹配 abcd/1、abcd/123、abcd/abc 等。连字符（-）和点（.）在基于字符串的路径中按字面意思解释。但是，没有附加字符的 abcd/ 将不匹配路由。为此，您需要将通配符包装在大括号中以使其可选：

forRoutes({
  path: 'abcd/{*splat}',
  method: RequestMethod.ALL,
});

中间件消费者

MiddlewareConsumer 是一个辅助类。它提供了几个内置方法来管理中间件。所有这些方法都可以简单地以流畅风格链式调用。forRoutes() 方法可以接受单个字符串、多个字符串、RouteInfo 对象、控制器类甚至多个控制器类。在大多数情况下，您可能只需传递一个用逗号分隔的控制器列表。下面是一个单个控制器的示例：

@@filename(app.module)
import { Module, NestModule, MiddlewareConsumer } from '@nestjs/common';
import { LoggerMiddleware } from './common/middleware/logger.middleware';
import { CatsModule } from './cats/cats.module';
import { CatsController } from './cats/cats.controller';

@Module({
  imports: [CatsModule],
})
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer
      .apply(LoggerMiddleware)
      .forRoutes(CatsController);
  }
}
@@switch
import { Module } from '@nestjs/common';
import { LoggerMiddleware } from './common/middleware/logger.middleware';
import { CatsModule } from './cats/cats.module';
import { CatsController } from './cats/cats.controller';

@Module({
  imports: [CatsModule],
})
export class AppModule {
  configure(consumer) {
    consumer
      .apply(LoggerMiddleware)
      .forRoutes(CatsController);
  }
}

info 提示 apply() 方法可以接受单个中间件，或多个参数来指定多个中间件。

排除路由

有时，我们可能希望排除某些路由不应用中间件。这可以使用 exclude() 方法轻松实现。exclude() 方法接受单个字符串、多个字符串或 RouteInfo 对象来标识要排除的路由。

以下是如何使用它的示例：

consumer
  .apply(LoggerMiddleware)
  .exclude(
    { path: 'cats', method: RequestMethod.GET },
    { path: 'cats', method: RequestMethod.POST },
    'cats/{*splat}',
  )
  .forRoutes(CatsController);

info 提示 exclude() 方法使用 path-to-regexp 包支持通配符参数。

在上面的示例中，LoggerMiddleware 将绑定到 CatsController 内定义的所有路由，除了传递给 exclude() 方法的三个路由。

这种方法在基于特定路由或路由模式应用或排除中间件时提供了灵活性。

函数式中间件

我们一直使用的 LoggerMiddleware 类非常简单。它没有成员、没有额外的方法，也没有依赖项。为什么我们不能只在一个简单的函数中定义它而不是一个类？事实上，我们可以。这种类型的中间件称为函数式中间件。让我们将日志记录中间件从基于类的转换为函数式中间件来说明差异：

@@filename(logger.middleware)
import { Request, Response, NextFunction } from 'express';

export function logger(req: Request, res: Response, next: NextFunction) {
  console.log(`Request...`);
  next();
};
@@switch
export function logger(req, res, next) {
  console.log(`Request...`);
  next();
};

并在 AppModule 中使用它：

@@filename(app.module)
consumer
  .apply(logger)
  .forRoutes(CatsController);

info 提示当您的中间件不需要任何依赖项时，请考虑使用更简单的函数式中间件替代方案。

多个中间件

如上所述，为了绑定按顺序执行的多个中间件，只需在 apply() 方法内提供一个逗号分隔的列表：

consumer.apply(cors(), helmet(), logger).forRoutes(CatsController);

全局中间件

如果我们想一次将中间件绑定到每个注册的路由，我们可以使用 INestApplication 实例提供的 use() 方法：

@@filename(main)
const app = await NestFactory.create(AppModule);
app.use(logger);
await app.listen(process.env.PORT ?? 3000);

info 提示在全局中间件中访问 DI 容器是不可能的。使用 app.use() 时，您可以使用函数式中间件代替。或者，您可以使用类中间件并在 AppModule（或任何其他模块）中使用 .forRoutes('*') 来使用它。

模块

学习如何在 NestJS 中使用模块来组织应用程序结构，包括功能模块、共享模块、模块重新导出、依赖注入和动态模块的概念。

异常过滤器

学习如何在 NestJS 中使用异常过滤器处理错误和异常