概述 - 中间件

优质

小牛编辑

133浏览

2023-12-01

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

Nest 中间件实际上等价于 express 中间件。从 Express 官方文档复制的中间件功能有很多：

中间件函数可以执行以下任务:
执行任何代码。
对请求和响应对象进行更改。
结束请求-响应周期。
调用堆栈中的下一个中间件函数。
如果当前的中间件函数没有结束请求-响应周期, 它必须调用 next() 将控制传递给下一个中间件函数。否则, 请求将被挂起。

Nest 中间件可以是一个函数，也可以是一个带有 @Injectable() 装饰器的类。这个类应该实现 NestMiddleware 接口。我们来创建一个例子，LoggerMiddleware 类:

logger.middleware.ts

import { Injectable, NestMiddleware, MiddlewareFunction } from '@nestjs/common';
@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  resolve(...args: any[]): MiddlewareFunction {
    return (req, res, next) => {
      console.log('Request...');
      next();
    };
  }
}

该 resolve() 方法必须返回常规的特定库的中间件 (req, res, next) => any

依赖注入

说到中间件, 也不例外。与提供者和控制器相同, 它们能够注入属于统一模块的依赖项（通过constructor）。

中间件放在哪里

中间件不能在 @Module() 装饰器中列出。我们必须使用 configure() 模块类的方法来设置它们。包含中间件的模块必须实现 NestModule 接口。让我们设置 LoggerMiddleware 在 ApplicationModule 关卡上。

app.module.ts

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

在上面的例子中, 我们已经设置了 LoggerMiddleware 的 /cats 的路由处理程序 CatsController 。MiddlewareConsumer 是一个帮助类。它提供了几种使用中间件的方法。他们都可以简单地链接。让我们来看看这些方法。

在 forRoutes() 可采取单个对象，多个对象，控制器类和甚至多个控制器类。在大多数情况下，你可能只是通过控制器，并用逗号分隔。以下是单个控制器的示例

app.module.ts

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

?> 该 apply() 方法可以采用单个中间件或一组中间件。

将参数传递给中间件

有时中间件的行为取决于自定义值，例如用户角色数组，选项对象等。我们可以将其他参数传递给 resolve() 来使用 with() 方法。看下面的例子：

app.moudle.ts

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

我们已经通过了一个自定义字符串 - ApplicationModule 的 with() 方法。现在我们必须调整 LoggerMiddleware 的 resolve() 方法。

logger.middleware.ts

import { Injectable, NestMiddleware, MiddlewareFunction } from '@nestjs/common';
@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  resolve(name: string): MiddlewareFunction {
    return (req, res, next) => {
      console.log(`[${name}] Request...`); // [ApplicationModule] Request...
      next();
    };
 }
}

该 name 的属性值将是 ApplicationModule。

异步中间件

从 resolve() 方法中返回异步函数没有禁忌。所以，resolve() 方法也可以写成 async 的。这种模式被称为 延迟中间件 。

logger.middleware.ts

import { Injectable, NestMiddleware, MiddlewareFunction } from '@nestjs/common';
@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  async resolve(name: string): Promise<MiddlewareFunction> {
    await someAsyncJob();
    return async (req, res, next) => {
      await someAsyncJob();
      console.log(`[${name}] Request...`); // [ApplicationModule] Request...
      next();
    };
 }
}

函数式中间件

LoggerMiddleware 很短。它没有成员，没有额外的方法，没有依赖关系。为什幺我们不能只使用一个简单的函数？这是一个很好的问题，因为事实上 - 我们可以做到。这种类型的中间件称为函数式中间件。让我们把 logger 转换成函数。

logger.middleware.ts

export function logger(req, res, next) {
  console.log(`Request...`);
  next();
};

现在在 ApplicationModule 中使用它。

app.module.ts

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

?> 当您的中间件没有任何依赖关系时，我们可以考虑使用函数式中间件。

多个中间件

如前所述，为了绑定顺序执行的多个中间件，我们可以在 apply() 方法内用逗号分隔它们。

export class ApplicationModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer
      .apply(cors(), helmet(), logger)
      .forRoutes(CatsController);
  }
}

全局中间件

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

const app = await NestFactory.create(ApplicationModule);
app.use(logger);
await app.listen(3000);