Microservices NestJS微服务异常处理

我已设置了一个微服务体系结构，该体系结构如下所示：

• api网关（

  NestFactory.create（AppModule）；

  ）
• 服务1（

  NestFactory.createMicroservice

  ）
• 服务2（

  NestFactory.createMicroservice

  ）

服务如下所示：

service.controller.ts
service.handler.ts

其中，

handler

类似于处理逻辑的典型整体中的服务

目前，我通过以下方式捕获异常：

处理程序调用数据库，但由于重复密钥（即电子邮件）而失败

我捕获此异常并将其转换为

RpcException

在ApiGateway中，我捕捉到

RpcException

如下所示：

    return new Promise<Type>((resolve, reject) => {
       this.clientProxy
        .send<Type>('MessagePattern', { dto: DTO })
        .subscribe(resolve, (err) => {
            logger.error(err);
            reject(err);
        });
    });

返回新承诺（（解决、拒绝）=>{
这个是.clientProxy
.send（'MessagePattern'，{dto:dto}）
.订阅（解析，（错误）=>{
记录器错误（err）；
拒绝（错误）；
});
});

我必须再次捕获被拒绝的承诺并抛出一个HttpException，以使

ExceptionFilter

发送正确的错误响应。在承诺中抛出错误而不是拒绝它是行不通的）

所以基本上，我有3个TryCatch块用于1个异常。 这在我看来很冗长

对于NestJS微服务，有没有更好的方法或最佳实践

---

我们是否可以为

this.clientProxy.send

接收的反弹消息设置

拦截器

，并通过管道将错误响应发送到客户端，而不显式捕获两次？

不是对您问题的完整答案，但总比没有好。：）

我尽量避免使用

.subscribe

，

拒绝（…）

方法。 即使

send

方法返回一个

可观察的

，在大多数情况下，您只需要一个响应。因此，在大多数情况下，

.toPromise（）

是有意义的。 一旦它成为一个承诺，您就可以使用async Wait语法，并且您没有回调，您可以有效地捕获所有异常（如果您愿意，还可以重试）。这有点帮助

try {
  const payload = { dto: DTO }; 
  const response = await this.clientProxy.send<Type>('MessagePattern', payload).toPromise();
} catch (err) {
  this.logger.error(err);
}

您应该实现

NestInterceptor

接口：

@Injectable()
export class CatchExceptionInterceptor implements NestInterceptor {
    intercept(context: ExecutionContext, stream$: Observable<any>): Observable<any> {
        return stream$.pipe(
            catchError(...)
        );
    }
}

@Injectable（）
导出类CatchExceptionInterceptor实现NestInterceptor{
截取（上下文：ExecutionContext，流$：可观察）：可观察{
返回流$.pipe(
捕获错误（…）
);
}
}

@Injectable()
export class CatchExceptionInterceptor implements NestInterceptor {
    intercept(context: ExecutionContext, stream$: Observable<any>): Observable<any> {
        return stream$.pipe(
            catchError(...)
        );
    }
}