NestJS如何实现Service层向拦截器传递自定义消息数据

两种实现方式均不会出现多请求数据串扰问题，可根据项目场景选择：

方案1：请求对象挂载（实现成本最低） #

利用每个HTTP请求独立的request对象生命周期存储自定义数据，无需额外封装。

1. 给对应Service开启请求作用域，注入请求对象，直接挂载自定义消息：

import { Injectable, Scope, Inject } from '@nestjs/common';
import { REQUEST } from '@nestjs/core';
import { Request } from 'express'; // fastify项目替换为对应框架的Request类型

@Injectable({ scope: Scope.REQUEST })
export class MyService {
  constructor(
    @Inject(REQUEST) private readonly req: Request,
    // 原有repository等依赖保持原有注入逻辑即可
  ) {}

  async create(dto: MyDTO): Promise<MyEntity> {
    const data = this.repository.create(dto);
    // 自定义键名存储消息，避免和框架内置属性冲突即可
    (this.req as any).customRespMsg = "insert successful";
    return this.repository.save(data);
  }
}

2. 修改拦截器，从执行上下文中取出提前挂载的消息，组装统一响应：

@Injectable()
export class MyInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler<any>): Observable<any> {    
    const req = context.switchToHttp().getRequest();
    return next.handle().pipe(
      map(data => ({
        Error: false,
        data,
        message: (req as any).customRespMsg ?? 'operation successful'
      })),
    );
  }
}

优缺点：代码量最少，无额外封装成本；Service会变为请求作用域，对性能有极微弱影响，绝大多数中小流量项目完全可以忽略。

方案2：AsyncLocalStorage 上下文存储（性能最优） #

基于Node.js原生AsyncLocalStorage实现异步调用链上下文隔离，Service可保持默认单例作用域，适合高并发场景。

1. 新建上下文存储工具文件src/common/request-context.ts：

import { AsyncLocalStorage } from 'async_hooks';

export const RequestContext = {
  als: new AsyncLocalStorage<Map<string, any>>(),
  set(key: string, value: unknown) {
    this.als.getStore()?.set(key, value);
  },
  get<T = unknown>(key: string): T | undefined {
    return this.als.getStore()?.get(key);
  }
}

2. 新建全局中间件初始化请求上下文，在src/common/request-context.middleware.ts写入：

import { Injectable, NestMiddleware } from '@nestjs/common';
import { NextFunction, Request, Response } from 'express';
import { RequestContext } from './request-context';

@Injectable()
export class RequestContextMiddleware implements NestMiddleware {
  use(_req: Request, _res: Response, next: NextFunction) {
    // 每个请求生成独立存储实例，天然隔离
    RequestContext.als.run(new Map(), next);
  }
}

3. 在AppModule中注册全局中间件：

import { Module, NestModule, MiddlewareConsumer } from '@nestjs/common';
import { RequestContextMiddleware } from './common/request-context.middleware';

@Module({
  // 原有模块配置保持不变
})
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer.apply(RequestContextMiddleware).forRoutes('*');
  }
}

4. Service中无需修改作用域，直接写入消息即可：

@Injectable() // 保持默认单例作用域，无需额外参数
export class MyService {
  // 原有依赖注入逻辑完全不变
  async create(dto: MyDTO): Promise<MyEntity> {
    const data = this.repository.create(dto);
    RequestContext.set('customRespMsg', 'insert successful');
    return this.repository.save(data);
  }
}

5. 拦截器中直接从上下文读取消息：

import { RequestContext } from './common/request-context';

@Injectable()
export class MyInterceptor implements NestInterceptor {
  intercept(_context: ExecutionContext, next: CallHandler<any>): Observable<any> {    
    return next.handle().pipe(
      map(data => ({
        Error: false,
        data,
        message: RequestContext.get<string>('customRespMsg') ?? 'operation successful'
      })),
    );
  }
}

优缺点：Service保持单例，无额外性能开销；需要多写少量上下文初始化代码，适合对性能要求高的大流量项目。

不推荐方案说明 #

不要为了传值直接修改Service返回结构为{ data, message }格式，这种方式会侵入所有业务方法的返回值类型定义，和原有实体类返回逻辑耦合，后续维护成本极高。

内容的提问来源于stack exchange，提问作者paranoid