nestjs 中的 rxjs

在 NestJS 中，RxJS 是其核心依赖之一，主要用于处理异步数据流 、拦截器（Interceptors） 、**过滤器（Filters）以及函数式响应式编程（FRP）**场景。

NestJS 深度集成了 RxJS，尤其是在处理 HTTP 请求的生命周期时。以下是 NestJS 中使用 RxJS 的核心场景、最佳实践和常见用法指南（基于 2025-2026 年的主流架构）。

1. 核心应用场景

A. 拦截器 (Interceptors) - 最常用的场景

拦截器是 RxJS 在 NestJS 中最强大的用武之地。你可以使用 RxJS 操作符来修改请求的响应、记录日志、转换数据或处理异常。

典型用例：统一响应格式包装

typescript 复制代码

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

export interface Response<T> {
  data: T;
  statusCode: number;
  message: string;
}

@Injectable()
export class TransformInterceptor<T> implements NestInterceptor<T, Response<T>> {
  intercept(context: ExecutionContext, next: CallHandler): Observable<Response<T>> {
    return next.handle().pipe(
      map((data) => ({
        data,
        statusCode: context.switchToHttp().getResponse().statusCode,
        message: 'Success',
      })),
    );
  }
}

关键点 ：next.handle() 返回一个 Observable，你必须通过 .pipe() 和操作符（如 map, tap, catchError）来处理它。

B. 异常过滤 (Exception Filters)

虽然通常用 try-catch，但在某些高级场景下，结合 RxJS 的 catchError 可以全局处理流式错误。

typescript 复制代码

import { catchError } from 'rxjs/operators';
import { throwError } from 'rxjs';

// 在拦截器或特定逻辑中
return next.handle().pipe(
  catchError((err) => {
    // 记录日志或转换错误格式
    console.error('Global Error:', err);
    return throwError(() => new HttpException('Custom Error', 500));
  }),
);

C. Controller 中的异步流处理

NestJS 的 Controller 方法可以直接返回 Observable。这在处理 Server-Sent Events (SSE) 或 WebSocket 流时非常有用。

典型用例：SSE 实时推送

typescript 复制代码

import { Controller, Get, MessageEvent, Sse } from '@nestjs/common';
import { Observable, interval } from 'rxjs';
import { map } from 'rxjs/operators';

@Controller('events')
export class EventsController {
  @Sse('sse')
  sse(): Observable<MessageEvent> {
    return interval(1000).pipe(
      map((_) => ({ data: { hello: 'world' } } as MessageEvent)),
    );
  }
}

2. 常用 RxJS 操作符在 NestJS 中的实践

在 NestJS 开发中，你不需要掌握 RxJS 的所有操作符，但以下几个是必须精通的：

操作符	场景	示例代码片段
`map`	转换响应数据（如统一封装 API 返回结构）。	`.pipe(map(data => ({ success: true, data })))`
`tap`	侧效应操作（如记录日志、监控耗时），不改变数据流。	`.pipe(tap(data => logger.log(data)))`
`catchError`	捕获流中的错误并转换为 NestJS 的 Exception。	`.pipe(catchError(err => throwError(() => new BadRequestException(err))))`
`finalize`	无论成功还是失败，最后都要执行的操作（如释放资源、结束计时）。	`.pipe(finalize(() => console.log('Request completed')))`
`switchMap` / `mergeMap`	在拦截器或服务中需要发起另一个异步请求时（高階 Observable）。	`.pipe(switchMap(user => this.auditService.log(user)))`
`shareReplay`	缓存热点数据流（如在 ConfigService 或共享服务中避免重复调用）。	`this.config$.pipe(shareReplay(1))`

3. 最佳实践与避坑指南 (2026 版)

✅ 1. 始终返回 Observable (在拦截器中)

在 Interceptor 中，永远不要 subscribe observable 然后返回一个 Promise 或普通值。必须保持流的连续性，让 NestJS 框架自己去 subscribe。

❌ 错误：

typescript 复制代码

// 别让框架失去对流的控制
next.handle().subscribe(data => { return data; });

✅ 正确：
typescript 复制代码
```
return next.handle().pipe(map(...));
```

✅ 2. 避免 "Observable Hell"

如果在 Service 层业务逻辑过于复杂，嵌套了多层 switchMap，代码会难以维护。

建议：对于复杂的同步/异步混合逻辑，考虑在 Service 内部使用 async/await，只在边界（Controller 或 Interceptor）暴露为 Observable。NestJS 完美支持混用。

typescript 复制代码

// Service 内部可以用 async/await 简化逻辑
async findAll() {
  const users = await this.repo.find();
  return users.map(u => this.transform(u));
}

// Controller 自动将其转为 Observable 处理
@Get()
findAll() {
  return this.service.findAll(); 
}

✅ 3. 内存泄漏防护

在 NestJS 的 Provider (Service) 中，如果你手动创建了 Subject 或 Timer 并 subscribe，务必在 OnModuleDestroy 钩子中取消订阅。

推荐模式 ：使用 takeUntil 或 Subject 配合 ngOnDestroy (类似 Angular) 的逻辑，或者直接使用 first()/take(1) 如果只需要一次触发。

typescript 复制代码

import { OnModuleDestroy } from '@nestjs/common';
import { Subject } from 'rxjs';
import { takeUntil } from 'rxjs/operators';

@Injectable()
export class MyService implements OnModuleDestroy {
  private destroy$ = new Subject<void>();

  startStreaming() {
    interval(1000)
      .pipe(takeUntil(this.destroy$))
      .subscribe(val => console.log(val));
  }

  onModuleDestroy() {
    this.destroy$.next();
    this.destroy$.complete();
  }
}

✅ 4. 调试技巧

使用 tap 操作符进行调试，而不是打断点（因为断点在异步流中很难捕捉）。

typescript 复制代码

.pipe(
  tap({
    next: val => console.log('Next:', val),
    error: err => console.error('Error:', err),
    complete: () => console.log('Complete'),
  })
)

4. 进阶：微服务中的 RxJS

如果你使用 NestJS Microservices (TCP, Redis, MQTT, Kafka)，RxJS 是底层通信的核心。

Client Proxy : client.send() 返回的是一个 Observable，你需要 subscribe 或使用 lastValueFrom 将其转为 Promise。

typescript 复制代码

// 推荐在现代 NestJS (v8+) 中使用 lastValueFrom 处理一次性消息
import { lastValueFrom } from 'rxjs';

const result = await lastValueFrom(this.client.send('sum', [1, 2]));

总结

在 NestJS 中：

Interceptor 是 RxJS 的主战场，用于切面编程。
Controller 可以返回 Observable 以支持流式响应 (SSE)。
Service 层建议优先使用 async/await 以保持业务逻辑清晰，除非涉及复杂的流式组合。
务必注意资源清理，防止内存泄漏。

如果你需要针对某个具体场景（比如"如何用 RxJS 实现请求重试"或"如何合并多个微服务响应"）的代码示例，请告诉我！