过滤器 - 简书

内置的异常层负责处理整个应用中抛出的所有异常，当捕获到未处理的异常时，最终用户将收到友好的响应；
每个发生的异常都由全局异常过滤器处理，当这个异常无法识别时(既不是HttpException，也不是其子类)，用户将收到一下响应：
```
{
    "statusCode": 500,
    "message": "Internal server error"
}
```

HttpException

Nest的内置基础异常类：HttpException

@Get()
async findAll() {
    throw new HttpException('Forbidden', HttpStatus.FORBIDDEN);
}

前台收到得响应：{ "statusCode": 403, "message": "Forbidden" }

HttpException的构造函数由两个必要参数来决定响应内容：response、status
response 定义JSON响应体，可以是 string、object
1. JSON响应体默认包含两个属性：statusCode、message
2. statusCode默认为 status 参数提供的状态码；
3. message则是基于状态的HTTP错误的简短描述；
4. 当 response 为 string 类型时，仅覆盖JSON响应体的消息部分，即message
5. 当 response 为 object 类型时，则覆盖整个JSON响应体，并由Nest去序列化对象，转为JSON响应返回；

status 是一个有效的HTTP状态码，应使用从 @nestjs/common 导入的 HttpStatus 枚举；

@Get()
findAll() {
    throw new HttpException({
        status: HttpStatus.FORBIDDEN,
        error: 'This is a custom message',
    }, 403);
}

自定义异常

自定义异常应继承HttpException，否则Nest无法识别并处理；

forbidden.exception.ts

export class ForbiddenException extends HttpException {
    constructor() {
        super('Forbidden', HttpStatus.FORBIDDEN);
    }
}

@Get()
async findAll() {
    throw new ForbiddenException();
}

当然，Nest也内置了一系列继承自HttpException的可用异常，都来自@nestjs/common

BadRequestException  UnauthorizedException  NotFoundException  ForbiddenException
NotAcceptableException  RequestTimeoutException  ConflictException  GoneException
PayloadTooLargeException  UnsupportedMediaTypeException  UnprocessableException
InternalServerErrorException  NotImplementedException  BadGatewayException
ServiceUnavailableException  GatewayTimeoutException

异常过滤器

过滤器.png

Exception Filter 的目的是获得对异常层的完全控制权，可以精确控制数据的响应；
异常过滤器应实现 ExceptionFilter<T> 接口，它提供了处理方法 catch(exception: T, host: ArgumentsHost)，其中，T表示处理的异常类型；
@Catch()：绑定所需的元数据到异常过滤器上，告知异常过滤器捕获的异常类型，支持传入多个参数；
```
nest g filter xxx     //创建过滤器
```

捕获HttpException的异常过滤器，通过 response.json() 发送自定义的响应数据；

http-exception.filter.ts

import { ExceptionFilter, Catch, ArgumentsHost, HttpException } from '@nestjs/common';
import { Request, Response } from 'express';

@Catch(HttpException)
export class HttpExceptionFilter implements ExceptionFilter {
    catch(exception: HttpException, host: ArgumentsHost) {
        //HttpArgumentsHost
        const ctx = host.switchToHttp();
        //借助Express来返回原生的Express类型化对象
        const response = ctx.getResponse<Response>();
        const request = ctx.getRequest<Request>();
        const status = exception.getStatus();
        //发送响应
        response
        .status(status)
        .json({
            statusCode: status,
            timestamp: new Date().toISOString(),
            path: request.url,
        });
    }
}

使用异常过滤器：@UseFilters()
1. @UseFilters()可以接收单个过滤器，也可以接收多个过滤器；应尽可能传入类而不是实例，因为Nest可以在整个模块中复用一个类的实例，从而减少内存使用；
2. 在处理程序上(控制器方法)
```
    @Post()
    @UseFilters(HttpExceptionFilter)
    async create(@Body() createCatDto: CreateCatDto) {
        throw new ForbiddenException();
    }
```
1. 在控制器上，作用于其中的所有方法
```
    @UseFilters(HttpExceptionFilter)
    export class CatsController {}
```
设置全局异常过滤器
1. main.ts
```
app.useGlobalFilters(new HttpExceptionFilter());
```
1. useGlobalFilters() 不会为网关和混合应用程序设置过滤器；
2. 就依赖注入而言，从模块外部注册的全局过滤器不能注入依赖，因为它不属于任何模块；为此，则在任何模块上去注册：
```
app.module.ts

    import { Module } from '@nestjs/common';
    import { APP_FILTER } from '@nestjs/core';

    @Module({
        providers: [{
            provide: APP_FILTER,
            useClass: HttpExceptionFilter,
        }],
    })
    export class AppModule {}
```
1. 这种注册方式下，任何模块都可以依赖注册异常过滤器对象。
为了捕获一切异常，不管是哪个异常类型，也不管异常是否处理，则将装饰器 @Catch() 的参数列表设置为空；
```
@Catch()
export class AllExceptionsFilter implements ExceptionFilter {
    catch(exception: unknown, host: ArgumentsHost) { }
}
```

异常过滤器也可以继承，如重用以实现的核心异常过滤器BaseExceptionFilter，将异常委托给基础过滤器；

import { BaseExceptionFilter } from '@nestjs/core';

@Catch()
export class AllExceptionsFilter extends BaseExceptionFilter {
    catch(exception: unknown, host: ArgumentsHost) {
        super.catch(exception, host);
    }
}

继承自基础类的过滤器必须由框架本身实例化，不能使用 new 手动创建实例；
还可以通过注入 HttpServer 来使用继承自基础类的全局过滤器

main.ts

const { httpAdapter } = app.get(HttpAdapterHost);
app.useGlobalFilters(new AllExceptionsFilter(httpAdapter));