參考檔案: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采用了內置的默認例外處理，因此不會出現由于出現未捕獲的例外導致程式崩潰，

自定義例外過濾器處理

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

如何自定義例外？

不重復造輪子是程式員的自我約束，首先我們新建我們自己的例外基類：

 1 import { HttpException } from "@nestjs/common";
 2 
 3 /**
 4  * 定義基礎例外類
 5  *
 6  * @export
 7  * @class BaseException
 8  * @extends {HttpException}
 9  */
10 export class BaseException extends HttpException {
11 
12     /**
13      * Creates an instance of BaseException.
14      * @param {number} exceptionCode 自定義例外編號
15      * @param {string} errorMessage  提示資訊
16      * @param {number} statusCode 狀態碼
17      * @memberof BaseException
18      */
19     constructor(public exceptionCode: number, public errorMessage: string, public statusCode: number) {
20         super({ exceptionCode: exceptionCode, errorMessage: errorMessage }, statusCode);        
21     }
22 
23     /**
24      * 獲取自定義例外代碼
25      *
26      * @return {*} 
27      * @memberof BaseException
28      */
29     getExceptionCode(): number {
30         return this.exceptionCode;
31     }
32 
33     getErrorMessage(): string {
34         return this.errorMessage;
35     }
36 
37     getStatusCode(): number {
38         return this.statusCode;
39     }
40 }

然后我們新建一個未授權例外型別，其中增加了自定義例外代碼：

1 import { HttpStatus } from "@nestjs/common";
2 import { BaseException } from "./base.exception";
3 
4 export class UnCauhtException extends BaseException {
5     constructor() {
6         super(40000, "系統運行例外，請聯系管理員！", HttpStatus.FORBIDDEN);
7     }
8 }

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

 1 import { ArgumentsHost, ExceptionFilter, HttpException } from "@nestjs/common";
 2 import { HttpArgumentsHost } from "@nestjs/common/interfaces";
 3 import { BaseException } from "src/exceptions/base.exception";
 4 import { Response, Request } from "express";
 5 
 6 /**
 7  * 例外基礎類過濾器
 8  *
 9  * @export
10  * @class BaseExceptionFilter
11  * @implements {ExceptionFilter<BaseException>}
12  */
13 export abstract class BaseExceptionFilter implements ExceptionFilter<BaseException>
14 {
15     /**
16      * 例外類捕獲
17      *
18      * @abstract
19      * @param {BaseException} exception
20      * @param {ArgumentsHost} host
21      * @memberof BaseExceptionFilter
22      */
23     abstract catch(exception: BaseException, host: ArgumentsHost);
24 
25     /**
26      * 獲取http請求背景關系引數
27      *
28      * @protected
29      * @param {ArgumentsHost} host
30      * @return {*} 
31      * @memberof BaseExceptionFilter
32      */
33     protected getHttpContext(host: ArgumentsHost) {
34         return host.switchToHttp();
35     }
36 
37     /**
38      * 獲取http 回應引數
39      *
40      * @protected
41      * @param {HttpArgumentsHost} httpContext
42      * @return {*} 
43      * @memberof BaseExceptionFilter
44      */
45     protected getResponse(httpContext: HttpArgumentsHost): Response {
46         return httpContext.getResponse<Response>();
47     }
48 
49     /**
50      * 獲取http請求引數
51      *
52      * @protected
53      * @param {HttpArgumentsHost} httpContext
54      * @return {*} 
55      * @memberof BaseExceptionFilter
56      */
57     protected getRequest(httpContext: HttpArgumentsHost): Request {
58         return httpContext.getRequest<Request>();
59     }
60 
61     /**
62      * 寫入例外資訊到客戶端
63      *
64      * @param {ArgumentsHost} host
65      * @param {BaseException} exception
66      * @memberof BaseExceptionFilter
67      */
68     protected writeToClient(host: ArgumentsHost, exception: BaseException) {
69         const ctx = this.getHttpContext(host);
70         if(exception instanceof BaseException){            
71             this.getResponse(ctx).status(exception.statusCode).json({
72                 exceptionCode: exception.getExceptionCode(),
73                 message: exception.getErrorMessage(),
74                 path: this.getRequest(ctx).url
75             });
76         }else {
77             const httpException=exception ;
78             this.getResponse(ctx).status(500).json({                
79                 message: "未處理的例外",
80                 path: this.getRequest(ctx).url
81             });
82         }
83         
84     }
85 }

新建未授權例外處理：

 1 import { ArgumentsHost, Catch } from "@nestjs/common";
 2 import { AuthException } from "src/exceptions/auth.exception";
 3 import { BaseException } from "src/exceptions/base.exception";
 4 import { BaseExceptionFilter } from "./base.exception.filter";
 5 
 6 @Catch(AuthException)
 7 export class AuthExceptionFilter extends BaseExceptionFilter
 8 {
 9     constructor(){
10         super();
11         console.log("授權例外建構式初始化"+new Date().toISOString());
12     }
13     catch(exception: AuthException, host: ArgumentsHost) {
14         exception.exceptionCode=40002;
15         console.log("授權例外執行"+new Date().toISOString());
16         this.writeToClient(host,exception);
17     }
18     
19 }

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

增加了Catch注解，只捕獲Authexception的例外，其他型別的例外此類不進行處理
繼承自定義例外處理類Baseexceptionfilter

應用范圍

例外處理類可應用于method、controller、全域，甚至同一個Controller可以定義多個自定義例外類

 1 import { Controller, ForbiddenException, Get, HttpException, HttpStatus, UseFilters } from '@nestjs/common';
 2 import { AppService } from './app.service';
 3 import { AuthException } from './exceptions/auth.exception';
 4 import { BusinessException } from './exceptions/business.exception';
 5 import { UnCauhtException } from './exceptions/uncauht.exception';
 6 import { AuthExceptionFilter } from './filters/auth.exception.filter';
 7 import { BusinessExceptionFilter } from './filters/business.exception.filter';
 8 
 9 
10 /**
11  * 帶有單個路由的基本控制器示例ff
12  */
13 @UseFilters(AuthExceptionFilter,BusinessExceptionFilter)
14 @Controller()
15 export class AppController {
16   constructor(private readonly appService: AppService) {}
17 
18   @Get()
19   getHello(): string {   
20     //throw new Error("666");
21     throw new BusinessException("自定義例外",HttpStatus.OK);
22     throw new AuthException();
23     throw new HttpException("自定義例外",HttpStatus.FORBIDDEN);
24     return this.appService.getHello();
25   }
26 
27   @Get("name")
28   getName():string
29   {
30     return "guozhiqi";
31   }
32 }

幾點說明：

我們使用Usefilters注解進行例外過濾器的添加
我們在Appcontroller中定義了兩種不同型別的自定義例外處理類
也就是我們Appcontroller中拋出的例外，只要是我們定義的這兩種，那么都可以被正常處理，

幾點疑問

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

Nestjs的例外處理并不復雜，復雜的是需要我們針對不同型別的例外進行處理，提取例外的共性，

轉載請註明出處，本文鏈接：https://www.uj5u.com/qiye/257343.html

標籤：其他

上一篇：《深入淺出React和Redux》(1) - React基礎

下一篇：js面向物件封裝級聯下拉選單串列

Nodejs Nestjs 路程 之 例外過濾器Exceptionfilter

Nestjs的例外處理

默認例外處理

自定義例外過濾器處理

應用范圍

幾點疑問

Nodejs Nestjs 路程之例外過濾器Exceptionfilter