初学nest.js注意事项之统一的请求返回体

一、统一的请求返回体。

/** ajaxResult.ts */

import { HttpStatus } from '@nestjs/common'

/**
 * 响应对象
 */
export class AjaxResult<T = any> {
    /** 状态码 */
    status: number

    /** 响应数据 */
    data?: T

    /** 响应消息 */
    message?: string

    /** 响应状态 */
    success?: boolean

    constructor(data: any, status: number, message: string, success: boolean) {
        this.data = data
        this.status = status
        this.message = message
        this.success = success
    }

    /**
     * 返回成功
     * @param data 数据
     * @param msg 消息
     * @param ses 状态
     * @returns AjaxResult
     */
    static success<T = any>(data?: T, msg?: string, ses?: boolean, code?: number): AjaxResult<T> {
        const status = code || HttpStatus.OK
        const message = msg || '操作成功'
        const success = ses || true
        return new AjaxResult<T>(data, status, message, success)
    }

    /**
     * 返回失败
     * @param msg 消息
     * @param status 状态码
     * @returns AjaxResult
     */
    static error<T = null>(msg?: string, status?: number, ses?: boolean): AjaxResult<T> {
        status = status || HttpStatus.INTERNAL_SERVER_ERROR
        const message = msg || '操作失败'
        const success = ses || false
        return new AjaxResult<T>(null, status, message, success)
    }
}

首先书写统一的请求返回体，包括成功的和失败的。代码如上，当然也可以自行实现。

二、响应拦截器

/**  response.ts */

import { Injectable, NestInterceptor, CallHandler, HttpStatus } from '@nestjs/common'
import { map } from 'rxjs/operators'
import { Observable } from 'rxjs'
import { AjaxResult } from "./ajaxResult";



@Injectable()
export class Response<T = any> implements NestInterceptor {
    intercept(context, next: CallHandler): Observable<AjaxResult<T>> {
        return next.handle().pipe(map(dataOf => {
            if (dataOf) {
                // 设置统一的成功状态码    
                const data = dataOf.data;
                const message = dataOf.message;
                const success = dataOf.success;
                const status = dataOf.status=='1'?200:dataOf.status;
                // 设置响应体
                return AjaxResult.success(data, message, success, status)
            }

        }))
    }
}

这里需要注意的地方有下面几个：

1、不能将代码中的status统一设置成200。

原因是只要你请求成功，不论你逻辑上是否能够成功，都将走响应拦截器。

2、需要判断status状态码是否为1。

原因是因为nest.js的post请求成功返回状态码为1。

3、需要判断代码中的dataof是否存在。

原因是因为在下载文件时，会触发两次处理请求，这样就会报错。

4、注意点的说明。

以上的这几点，目前仅存在与我的书写习惯。其余方法是否会存在上述的情况，目前位置，请大家自行探索。

代码参考：

nest.js的中文翻译响应拦截器

nest.js的官方英文响应拦截器地址

三、异常过滤器

/** catch.ts */


/**
 *  定义捕获所有异常（Exception）和 错误（Error）
 *  的全局异常/错误过滤器，需在 app.module.ts 中注册该过滤器
 */

import { ArgumentsHost, Catch, ExceptionFilter, HttpException, HttpStatus } from "@nestjs/common";
import { HttpAdapterHost } from "@nestjs/core";
import { Request, Response } from "express";
import { AjaxResult } from "./ajaxResult";


@Catch()
export class HttpFilter implements ExceptionFilter {
    constructor(private readonly httpAdapterHost: HttpAdapterHost) { }
    catch(exception: any, host: ArgumentsHost) {
        const { httpAdapter } = this.httpAdapterHost;
        const ctx = host.switchToHttp();
        const request = ctx.getRequest<Request>();
        const response = ctx.getResponse<Response>();
        const statusCode = exception instanceof HttpException ? exception.getStatus() : HttpStatus.INTERNAL_SERVER_ERROR;        
                  
        const resContents=AjaxResult.error(exception?.message,statusCode)
        // 使用不特定于平台（express 或 fastify）的方式（httpAdapter）返回响应内容
        httpAdapter.reply(response, resContents, statusCode);
    }
}

1、注意

这里使用的是异常过滤器而不是异常拦截器，不要弄混淆了。

代码参考：

nest.js中文翻译的异常过滤器链接

nest.js官方英文异常过滤器链接