【Nest 学习笔记】AOP切片编程

切片编程 AOP

把通用逻辑抽离出来，通过切面的方式添加到某个地方，可以复用和动态增删切面逻辑。

中间件 Middleware

Middleware 中间件属于全局中间件（Middleware 是 Express 的概念）

常用于对请求接口进行日志记录

// main.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { NextFunction, Request, Response } from 'express';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);

  app.use(function(req: Request, res: Response, next: NextFunction) {
    console.log('=========== 中间件拦截 ===========')

    console.log('请求前');
    // TODO: 请求前的进行切片化处理

    next(); // 进入具体请求接口中

    // TODO：请求后的切片化处理
    console.log('请求后');
  });
  
  await app.listen(3000);
}
bootstrap();

// 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 {
    console.log('getHello')
    return this.appService.getHello();
  }
}

鉴权 Guard

可以用于在调用某个 Controller 之前判断权限，返回 true 或者 false 来决定是否放行

常用于：请求鉴权（登录后，才能进行接口请求）

生成后的 Guard 文件

如何使用

1、局部使用 （单条请求）

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

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

  @Get('getHello')
  @UseGuards(LoginGuard) // 使用 Guard
  getHello(): string {
    console.log('getHello')
    return this.appService.getHello();
  }
}

2、全局使用

方式一：在 main.ts 中进行全局使用

// main.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { LoginGuard } from './login.guard';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);

  // * 全局鉴权
  app.useGlobalGuards(new LoginGuard())
  
  await app.listen(3000);
}
bootstrap();

方式二：在 AppModule 中进行全局使用

// app.module.ts
import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { APP_GUARD } from '@nestjs/core';
import { LoginGuard } from './login.guard';

@Module({
  imports: [],
  controllers: [AppController],
  providers: [
    AppService,
    {
      provide: APP_GUARD,
      useClass: LoginGuard
    }
  ],
})
export class AppModule {}

两者的区别：

前者：手动 new 的 Guard 实例，不在 IoC 容器里

后者：用 provider 的方式声明的 Guard 是在 IoC 容器里的，可以注入别的 provider

如：

// login.guard.ts
import { CanActivate, ExecutionContext, Inject, Injectable } from '@nestjs/common';
import { Observable } from 'rxjs';
import { AppService } from './app.service';

@Injectable()
export class LoginGuard implements CanActivate {

  // 注入 AppService  
  @Inject(AppService)
  private appService: AppService;

  canActivate(
    context: ExecutionContext,
  ): boolean | Promise<boolean> | Observable<boolean> {

    console.log('登录检查', this.appService.getHello())

    return false;
  }
}

拦截器 Interceptor

在目标 Controller 方法前后加入一些逻辑

如何使用

方式一：某条请求

import { Controller, Get, UseGuards, UseInterceptors } from '@nestjs/common';
import { AppService } from './app.service';
import { TimeInterceptor } from './time.interceptor';

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

  @Get('getNest')
  @UseInterceptors(TimeInterceptor)
  getNest():string {
    return 'getNest'
  }
}

方式二：作用于单个 Controller

import { Controller, Get, UseGuards, UseInterceptors } from '@nestjs/common';
import { AppService } from './app.service';
import { TimeInterceptor } from './time.interceptor';

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

  @Get('getNest')
  getNest():string {
    return 'getNest'
  }
}

方式三：作用于所有 Controller

// main.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { TimeInterceptor } from './time.interceptor';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.useGlobalInterceptors(new TimeInterceptor());
    
  await app.listen(3000);
}
bootstrap();

或

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { APP_INTERCEPTOR } from '@nestjs/core';
import { TimeInterceptor } from './time.interceptor';

@Module({
  imports: [],
  controllers: [AppController],
  providers: [
    AppService,
    {
      provide: APP_INTERCEPTOR,
      useClass: TimeInterceptor
    }
  ],
})
export class AppModule {}

两者区别：在 Guard 已提到

Middleware 与 Intercepator 的区别：

• Middleware：只能作用于所有 Controller；Intercepator ：不仅可以作用于所有 Controller，还可以作用于单个 Handler 或 Controller
• Middleware：拿不到调用的 controller 和 handler；interceptor 可以拿到调用的 controller 和 handler

管道 Pipe

用来对参数做一些检验和转换

如何使用

import { Controller, Get, Query, UseGuards, UseInterceptors } from '@nestjs/common';
import { AppService } from './app.service';
import { ValidatePipe } from './validate.pipe';

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

  @Get('savePhone')
  savePhone(@Query('phone', ValidatePipe) phone: string) {
    return phone
  }
}

异常 ExceptionFilter

如何使用

import { Controller, Get, Query, UseGuards, UseInterceptors } from '@nestjs/common';
import { AppService } from './app.service';
import { ValidatePipe } from './validate.pipe';
import { TestFilter } from './test.filter';

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

  @Get('savePhone')
  @UseFilters(TestFilter)  
  savePhone(@Query('phone', ValidatePipe) phone: string) {
    return phone
  }
}

或

import { Controller, Get, Query, UseGuards, UseInterceptors } from '@nestjs/common';
import { AppService } from './app.service';
import { ValidatePipe } from './validate.pipe';
import { TestFilter } from './test.filter';

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

  @Get('savePhone')
  savePhone(@Query('phone', ValidatePipe) phone: string) {
    return phone
  }
}

或

import { TestFilter } from './test.filter';
app.useGlobalFilters(new TestFilter())

或

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { APP_FILTER } from '@nestjs/core';
import { TestFilter } from './test.filter';

@Module({
  imports: [],
  controllers: [AppController],
  providers: [
    AppService,
    {
      provide: APP_FILTER,
      useClass: TestFilter
    }
  ],
})
export class AppModule {}

总结

几种 AOP 编程的调用顺序

• 会先调用 Guard，判断是否有权限等，如果没有权限，抛出的 ForbiddenException 会被 ExceptionFilter 处理
• 如果有权限，就会调用到拦截器，拦截器组织了一个链条，一个个的调用，最后会调用的 controller 的方法：
• 调用 controller 方法之前，会使用 pipe 对参数做处理