nestjs学习13：interceptor与rxjsinterceptor常用rxjs来组织异步逻辑，常用的有map响

关于对rxjs的描述，请参考这篇文章对rxjs的理解和基本使用。

interceptor都是和rxjs配合使用的，先看看在interceptor中有那些常用的操作符。

map

生成一个 interceptor：

nest g interceptor map-test --no-spec --flat

使用 map operator 来对 controller 返回的数据做一些修改：

import { CallHandler, ExecutionContext, Injectable, NestInterceptor } from '@nestjs/common';
import { map, Observable } from 'rxjs';

@Injectable()
export class MapTestInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    return next.handle().pipe(map(data => {
      return {
        code: 200,
        message: 'success',
        data
      }
    }))
  }
}

在 controller 里引入下：

现在返回的数据就变成了这样。

map 算是在 nest interceptor 里必用的 rxjs operator 了。

可以看到interceptor使用的第一个场景：转换请求 / 响应数据（最常用）。

上面其实展示了如何转换响应数据，下面再看看如何转换请求数据：

import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
import { Observable } from 'rxjs';

@Injectable()
export class RequestTransformInterceptor implements NestInterceptor {
  // 核心方法：拦截请求，处理入参后再执行控制器逻辑
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    // 1. 获取 HTTP 上下文（拿到请求对象）
    const ctx = context.switchToHttp();
    const request = ctx.getRequest();

    // 2. 统一处理入参：覆盖原始请求的 query/params/body
    // 处理 URL 参数（如 /users/:id → id 从字符串转数字）
    if (request.params) {
      request.params = this.transformParams(request.params);
    }

    // 3. 执行控制器方法（此时入参已被转换）
    return next.handle();
  }

一般拦截器Interceptor是全局批量转换请求参数，单个参数的精准转换 + 验证，还是要使用管道 pipe。

tap

tap不会修改响应数据，而是执行一些额外逻辑，比如记录日志、更新缓存等

下面看一下记录日志的例子：

import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
import { Observable } from 'rxjs';
import { tap } from 'rxjs/operators';

@Injectable()
export class LoggingInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    const now = Date.now();
    const request = context.switchToHttp().getRequest();
    const { method, url } = request; // 获取请求方法和路径

    // 执行控制器方法，响应返回后触发 tap 回调
    return next.handle().pipe(
      tap(() => {
        console.log(`[${method}] ${url} 耗时: ${Date.now() - now}ms`);
        // 输出示例：[GET] /api/users 耗时: 15ms
      })
    );
  }
}

对于高频访问、数据变更少的接口（比如首页配置、商品分类），可以用拦截器 + tap 来缓存响应结果，指定时间内重复请求直接返回缓存，提升性能。

import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
import { Observable, of } from 'rxjs';
import { tap } from 'rxjs/operators';

// 缓存容器
const cache = new Map<string, { data: any; expire: number }>();
const CACHE_TTL = 60 * 1000; // 缓存1分钟

@Injectable()
export class CacheInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    const request = context.switchToHttp().getRequest();
    const cacheKey = `${request.method}:${request.url}`; // 缓存键：方法+路径

    // 检查缓存是否存在且未过期
    const cached = cache.get(cacheKey);
    if (cached && Date.now() < cached.expire) {
      return of(cached.data); // 直接返回缓存数据，不执行控制器方法
    }

    // 执行控制器方法，缓存结果
    return next.handle().pipe(
      tap((data) => {
        cache.set(cacheKey, {
          data,
          expire: Date.now() + CACHE_TTL,
        });
      })
    );
  }
}

可以看到，在 tap 中把请求结果缓存起来，下次再用时直接返回缓存。

catchError

controller 里很可能会抛出错误，这些错误会被 exception filter 处理，返回不同的响应，但在那之前，我们可以在 interceptor 里先处理下。

import { CallHandler, ExecutionContext, Injectable, Logger, NestInterceptor } from '@nestjs/common';
import { catchError, Observable, throwError } from 'rxjs';

@Injectable()
export class CatchErrorTestInterceptor implements NestInterceptor {
  private readonly logger = new Logger(CatchErrorTestInterceptor.name)

  intercept (context: ExecutionContext, next: CallHandler): Observable<any> {
    return next.handle().pipe(catchError(err => {
      this.logger.error(err.message, err.stack)
      return throwError(() => err)
    }))
  }
}

这里我们就是日志记录了一下，当然你也可以改成另一种错误，重新 throwError。

打印了两次错误：

一次是我们在 interceptor 里打印的，一次是 exception filter 打印的。

timeout

接口如果长时间没返回，要给用户一个接口超时的响应，这时候就可以用 timeout operator。

import { CallHandler, ExecutionContext, Injectable, NestInterceptor, RequestTimeoutException } from '@nestjs/common';
import { catchError, Observable, throwError, timeout, TimeoutError } from 'rxjs';

@Injectable()
export class TimeoutInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    return next.handle().pipe(
      timeout(3000),
      catchError(err => {
        if(err instanceof TimeoutError) {
          console.log(err);
          return throwError(() => new RequestTimeoutException());
        }
        return throwError(() => err);
      })
    )
  }
}