Exceptionfilter異常過濾器怎么在nestjs中使用

Exceptionfilter異常過濾器怎么在nestjs中使用？針對這個問題，這篇文章詳細介紹了相對應的分析和解答，希望可以幫助更多想解決這個問題的小伙伴找到更簡單易行的方法。

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中拋出的異常，只要是我們定義的這兩種，那么都可以被正常處理。

幾點疑問

Usefitlers中我們自定義的異常處理類會初始化幾次？
答案：我們通過類型注冊到Appcontroller的自定義異常類只會在程序初始化的時候初始化一次。也就是說程序啟動之后，每個

controller、每個method定義了哪些異常處理類都已經確定。
如果我們捕獲到異常，但不進行任何處理，會發生什么？
答案：如果我們的異常處理方法什么也不做，那么恭喜你，會成功的將瀏覽器請求hang死，因為異常未處理，那么瀏覽器會一直得不到響應。

多個異常之間的處理順序如何？
答案：如果多個異常處理均可以捕獲到該異常，那么只有第一個有效，也就是說異常處理類和 中間件不同，異常處理類只能其中一個處理，而中間件需要都進行處理。

Nestjs的@Usefilters 像誰？
首先從JS角度來看，像Angular，如果往后端看，最像Spring。 

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

關于Exceptionfilter異常過濾器怎么在nestjs中使用問題的解答就分享到這里了，希望以上內容可以對大家有一定的幫助，如果你還有很多疑惑沒有解開，可以關注億速云行業資訊頻道了解更多相關知識。