中间件与管道

Nest中间件

中间件就是一个函数，在路由处理器之前调用。这就表示中间件函数可以访问到请求和响应对象以及应用的请求响应周期中的next()中间间函数。

Nest中间件实际上和Express的中间件是一样的，Express文档中对中间件的描述如下：

执行任意的代码
对请求/响应做操作
终结请求-响应周期
调用下一个栈中的中间件函数
如果当前的中间间函数没有终结请求响应周期，那么它必须调用next()方法将控制权传递给下一个中间件函数。否则请求将被挂起

中间件定义

Nest允许你使用函数或者类来实现自己的中间件。如果用类实现，则需要使用@Injectable()装饰，并且实现NestMiddleware接口。

import { Injectable, NestMiddleware } from "@nestjs/common";
import { Request, Response } from "express";

@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: Function) {
    console.log("Request...");
    next();
  }
}

或者我们也可以使用函数式中间件，函数式的中间件可以用一个简单无依赖函数来实现：

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

应用中间件

@Module()装饰器中并不能指定中间件参数，我们可以在模块类的构configure()方法中应用中间件，下面的代码会应用一个ApplicationModule级别的日志中间件LoggerMiddleware。

@Module({
  imports: [CatsModule]
})
export class ApplicationModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer.apply(LoggerMiddleware).forRoutes("cats");
  }
}

上面的代码forRoutes方法表示只将中间件应用在cats路由上，还可以是指定的HTTP方法，甚至是路由通配符：

.forRoutes({ path: 'cats', method: RequestMethod.GET });
.forRoutes({ path: 'ab*cd', method: RequestMethod.ALL });

当然，你也可以指定不包括某些路由规则：

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

不过请注意exclude方法不能运用在函数式的中间件上，而且这里指定的path也不支持通配符，这只是个快捷方法，如果你真的需要某种路由级别的控制，那完全可以把逻辑写在一个单独的中间件中。我们也可以用apply方法传入多个中间件参数即可：

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

管道

管道（Pipes）是一个用@Injectable()装饰过的类，它必须实现PipeTransform接口。

从官方的示意图中我们可以看出来管道pipe和过滤器filter之间的关系：管道偏向于服务端控制器逻辑，过滤器则更适合用客户端逻辑。过滤器在客户端发送请求后处理，管道则在控制器接收请求前处理。管道通常有两种作用：

转换/变形：转换输入数据为目标格式
验证：对输入数据时行验证，如果合法让数据通过管道，否则抛出异常。

管道会处理控制器路由的参数，Nest会在方法调用前插入管道，管道接收发往该方法的参数，此时就会触发上面两种情况。然后路由处理器会接收转换过的参数数据并处理后续逻辑。Nest内置了两种管道：ValidationPipe和ParseIntPipe。

@Injectable()
export class ValidationPipe implements PipeTransform {
  transform(value: any, metadata: ArgumentMetadata) {
    return value;
  }
}

类验证器

因为我们前面已经在控制器参数上使用了@body装饰器，并且使用TypeScript的类型声明它为CreateCatDto，如下：

async create(@Body() createCatDto: CreateCatDto) {
  this.catsService.create(createCatDto);
}

要使用类验证器，你需要先安装class-validator库。class-validator可以让你使用给类变量加装饰器的写法给类添加额外的验证功能。这样以来我们就可以直接在原始的CreateCatDto类上添加验证装饰器了，这样看起来就整洁多了，而且还没有重复代码：

import { IsString, IsInt } from "class-validator";

export class CreateCatDto {
  @IsString()
  readonly name: string;

  @IsInt()
  readonly age: number;

  @IsString()
  readonly breed: string;
}

不过管道验证器中的代码也需要适配一下：

@Injectable()
export class ValidationPipe implements PipeTransform<any> {
  async transform(value: any, { metatype }: ArgumentMetadata) {
    if (!metatype || !this.toValidate(metatype)) {
      return value;
    }
    const object = plainToClass(metatype, value);
    const errors = await validate(object);
    if (errors.length > 0) {
      throw new BadRequestException("Validation failed");
    }
    return value;
  }

  private toValidate(metatype: Function): boolean {
    const types: Function[] = [String, Boolean, Number, Array, Object];
    return !types.includes(metatype);
  }
}

注意这次的transform是async异步的，因为内部需要用到异步验证方法。Nest是支持你这么做的，因为管道可以是异步的。然后我们可以插入这个管道，位置可以是方法级别的，也可以是参数级别的。

参数作用域

@Post()
async create(
  @Body(new ValidationPipe()) createCatDto: CreateCatDto,
) {
  this.catsService.create(createCatDto);
}

方法作用域

@Post()
@UsePipes(new ValidationPipe())
async create(@Body() createCatDto: CreateCatDto) {
  this.catsService.create(createCatDto);
}

管道修饰器入参可以是类而不必是管道实例：

@Post()
@UsePipes(ValidationPipe)
async create(@Body() createCatDto: CreateCatDto) {
  this.catsService.create(createCatDto);
}

这样以来将实例化过程留给框架去做并肝启用依赖注入。由于ValidationPipe被尽可能的泛化，所以它可以直接使用在全局作用域上。

async function bootstrap() {
  const app = await NestFactory.create(ApplicationModule);
  app.useGlobalPipes(new ValidationPipe());
  await app.listen(3000);
}
bootstrap();

转换

我们还可以用管道来进行数据转换，比如说上面的例子中age虽然声明的是int类型，但是我们知道HTTP请求传递的都是纯字符流，所以通常我们还要把期望传进行类型转换。

@Injectable()
export class ParseIntPipe implements PipeTransform<string, number> {
  transform(value: string, metadata: ArgumentMetadata): number {
    const val = parseInt(value, 10);
    if (isNaN(val)) {
      throw new BadRequestException("Validation failed");
    }
    return val;
  }
}

上面这个管道的功能就是强制转换成Int类型，如果转换不成功就抛出异常。我们可以针对性的对传入控制器的某个参数插入这个管道：

@Get(':id')
async findOne(@Param('id', new ParseIntPipe()) id) {
  return await this.catsService.findOne(id);
}

最近更新于0001-01-01