Nodejs Nestjs 路程 之 異常過濾器Exceptionfilter

參考文件:docs.nestjs.cn

說起Nestjs的異常過濾器，不能不提.Net的全域性過濾器Filter，功能那是相當的強悍，用理論話說叫AOP 面向切面程式設計，可謂方便了太多需要異常處理的場景。說回Nestjs的異常過濾器，實現類似的功能，採用相似的處理方式，只不過一個面向C#，一個面向Nodejs，很榮幸的我，在兩個框架都找到了類似的東西。

面向切面程式設計AOP，是一種類似於程式設計規範的東東，同門師兄弟有叫面向介面程式設計、SOLID原則等等。

Nestjs的異常處理

預設異常處理

Nestjs內建了預設的全域性異常過濾器，處理能夠轉換成Httpexception的異常。

如果是Httpexception或其子類異常，那麼會返回該異常的JSON格式：

{"exceptionCode":40005,"message":"自定義異常","path":"/"}

如果不是Httpexception或其子類異常，那麼會返回：

{"statusCode":500,"message":"Internal server error"}

由於Nestjs採用了內建的預設異常處理，因此不會出現由於出現未捕獲的異常導致程式崩潰。

 

自定義異常過濾器處理

由於內建異常處理返回值格式無法調整，因此自定義異常就顯得又為正常。自定義異常可以使返回異常資訊自定義，且可以增加自定義異常編碼，方便客戶端人員根據異常編碼進行不同的展示。

如何自定義異常？

不重複造輪子是程式設計師的自我約束，首先我們新建我們自己的異常基類：

import { HttpException } from "@nestjs/common";

/**
 * 定義基礎異常類
 *
 * @export
 * @class BaseException
 * @extends {HttpException}
 */
export class BaseException extends HttpException {

    /**
     * Creates an instance of BaseException.
     * @param {number} exceptionCode 自定義異常編號
     * @param {string} errorMessage  提示資訊
     * @param {number} statusCode 狀態碼
     * @memberof BaseException
     */
    constructor(public exceptionCode: number, public errorMessage: string, public statusCode: number) {
        super({ exceptionCode: exceptionCode, errorMessage: errorMessage }, statusCode);        
    }

    /**
     * 獲取自定義異常程式碼
     *
     * @return {*} 
     * @memberof BaseException
     */
    getExceptionCode(): number {
        return this.exceptionCode;
    }

    getErrorMessage(): string {
        return this.errorMessage;
    }

    getStatusCode(): number {
        return this.statusCode;
    }
}

然後我們新建一個未授權異常型別，其中增加了自定義異常程式碼：

import { HttpStatus } from "@nestjs/common";
import { BaseException } from "./base.exception";

export class UnCauhtException extends BaseException {
    constructor() {
        super(40000, "系統執行異常，請聯絡管理員！", HttpStatus.FORBIDDEN);
    }
}

建立好了自定義異常，那麼我們就需要處理未授權異常，首先新建自定義異常處理基類，請注意 此處我們使用的事Express：

import { ArgumentsHost, ExceptionFilter, HttpException } from "@nestjs/common";
import { HttpArgumentsHost } from "@nestjs/common/interfaces";
import { BaseException } from "src/exceptions/base.exception";
import { Response, Request } from "express";

/**
 * 異常基礎類過濾器
 *
 * @export
 * @class BaseExceptionFilter
 * @implements {ExceptionFilter<BaseException>}
 */
export abstract class BaseExceptionFilter implements ExceptionFilter<BaseException>
{
    /**
     * 異常類捕獲
     *
     * @abstract
     * @param {BaseException} exception
     * @param {ArgumentsHost} host
     * @memberof BaseExceptionFilter
     */
    abstract catch(exception: BaseException, host: ArgumentsHost);

    /**
     * 獲取http請求上下文引數
     *
     * @protected
     * @param {ArgumentsHost} host
     * @return {*} 
     * @memberof BaseExceptionFilter
     */
    protected getHttpContext(host: ArgumentsHost) {
        return host.switchToHttp();
    }

    /**
     * 獲取http 響應引數
     *
     * @protected
     * @param {HttpArgumentsHost} httpContext
     * @return {*} 
     * @memberof BaseExceptionFilter
     */
    protected getResponse(httpContext: HttpArgumentsHost): Response {
        return httpContext.getResponse<Response>();
    }

    /**
     * 獲取http請求引數
     *
     * @protected
     * @param {HttpArgumentsHost} httpContext
     * @return {*} 
     * @memberof BaseExceptionFilter
     */
    protected getRequest(httpContext: HttpArgumentsHost): Request {
        return httpContext.getRequest<Request>();
    }

    /**
     * 寫入異常資訊到客戶端
     *
     * @param {ArgumentsHost} host
     * @param {BaseException} exception
     * @memberof BaseExceptionFilter
     */
    protected writeToClient(host: ArgumentsHost, exception: BaseException) {
        const ctx = this.getHttpContext(host);
        if(exception instanceof BaseException){            
            this.getResponse(ctx).status(exception.statusCode).json({
                exceptionCode: exception.getExceptionCode(),
                message: exception.getErrorMessage(),
                path: this.getRequest(ctx).url
            });
        }else {
            const httpException=exception ;
            this.getResponse(ctx).status(500).json({                
                message: "未處理的異常",
                path: this.getRequest(ctx).url
            });
        }
        
    }
}

新建未授權異常處理：

import { ArgumentsHost, Catch } from "@nestjs/common";
import { AuthException } from "src/exceptions/auth.exception";
import { BaseException } from "src/exceptions/base.exception";
import { BaseExceptionFilter } from "./base.exception.filter";

@Catch(AuthException)
export class AuthExceptionFilter extends BaseExceptionFilter
{
    constructor(){
        super();
        console.log("授權異常建構函式初始化"+new Date().toISOString());
    }
    catch(exception: AuthException, host: ArgumentsHost) {
        exception.exceptionCode=40002;
        console.log("授權異常執行"+new Date().toISOString());
        this.writeToClient(host,exception);
    }
    
}

針對未授權異常處理類，進行幾點說明：

1. 增加了Catch註解，只捕獲Authexception的異常，其他型別的異常此類不進行處理
2. 繼承自定義異常處理類Baseexceptionfilter

應用範圍

異常處理類可應用於method、controller、全域性，甚至同一個Controller可以定義多個自定義異常類

import { Controller, ForbiddenException, Get, HttpException, HttpStatus, UseFilters } from '@nestjs/common';
import { AppService } from './app.service';
import { AuthException } from './exceptions/auth.exception';
import { BusinessException } from './exceptions/business.exception';
import { UnCauhtException } from './exceptions/uncauht.exception';
import { AuthExceptionFilter } from './filters/auth.exception.filter';
import { BusinessExceptionFilter } from './filters/business.exception.filter';


/**
 * 帶有單個路由的基本控制器示例ff
 */
@UseFilters(AuthExceptionFilter,BusinessExceptionFilter)
@Controller()
export class AppController {
  constructor(private readonly appService: AppService) {}

  @Get()
  getHello(): string {   
    //throw new Error("666");
    throw new BusinessException("自定義異常",HttpStatus.OK);
    throw new AuthException();
    throw new HttpException("自定義異常",HttpStatus.FORBIDDEN);
    return this.appService.getHello();
  }

  @Get("name")
  getName():string
  {
    return "guozhiqi";
  }
}

幾點說明：

1. 我們使用Usefilters註解進行異常過濾器的新增
2. 我們在Appcontroller中定義了兩種不同型別的自定義異常處理類
3. 也就是我們Appcontroller中丟擲的異常，只要是我們定義的這兩種，那麼都可以被正常處理。

幾點疑問

1. Usefitlers中我們自定義的異常處理類會初始化幾次？
   答案：我們通過型別註冊到Appcontroller的自定義異常類只會在程式初始化的時候初始化一次。也就是說程式啟動之後，每個controller、每個method定義了哪些異常處理類都已經確定。
2. 如果我們捕獲到異常，但不進行任何處理，會發生什麼？
   答案：如果我們的異常處理方法什麼也不做，那麼恭喜你，會成功的將瀏覽器請求hang死，因為異常未處理，那麼瀏覽器會一直得不到響應。
3. 多個異常之間的處理順序如何？
   答案：如果多個異常處理均可以捕獲到該異常，那麼只有第一個有效，也就是說異常處理類和 中介軟體不同，異常處理類只能其中一個處理，而中介軟體需要都進行處理。
4. Nestjs的@Usefilters 像誰？
   首先從JS角度來看，像Angular，如果往後端看，最像Spring。

 

Nestjs的異常處理並不複雜，複雜的是需要我們針對不同型別的異常進行處理，提取異常的共性。