切片编程 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 对参数做处理