Nest

什么是 NestJS？它的主要特性有哪些？

NestJS 是一个基于 TypeScript 开发的 Node.js 后端框架，旨在构建高效、可扩展和易维护的服务端应用。

其主要特性包括：

• 模块化结构：将应用划分为独立模块，便于管理和扩展；
• 依赖注入：通过内置的 DI 容器自动管理依赖，降低耦合；
• 装饰器：利用 TypeScript 的装饰器语法，简化控制器、服务、管道等组件的定义；
• 中间件、管道、守卫、拦截器、异常过滤器：提供丰富的机制，方便处理请求预处理、数据验证、权限校验、响应格式转换以及异常处理；
• 微服务支持：内置对微服务架构的支持，可通过多种传输协议（如 TCP、Redis、NATS 等）构建分布式系统。

NestJS 核心设计思想是什么？为什么适合大型项目？

• 依赖注入 (DI)：通过 @Injectable 装饰器自动管理类依赖，解耦代码，提高可测试性
• 模块化架构：使用 @Module 划分功能边界（如 Controllers、Providers、Imports），支持按需加载
• 分层设计：强制分离 Controller（路由）、Service（业务）、Repository（数据层），适合团队协作
• TypeScript 原生：强类型约束减少低级错误，提升大型项目可维护性

NestJS 的依赖注入机制是如何工作？

NestJS 内置了一个依赖注入容器，开发者只需要在构造函数中声明所需依赖项，框架就会自动实例化并注入对应的服务或提供者。

这种方式：

• 降低了耦合：组件之间通过接口通信，便于替换和测试；
• 提高了代码可维护性：依赖关系在模块中统一管理。

其实现原理依赖于 TypeScript 的元数据和装饰器，使得依赖关系自动解析并管理。

如何在 NestJS 中使用中间件？

中间件是在请求到达路由处理之前执行的函数，用于日志记录、认证检查、请求转换等。
使用步骤：

1. 创建中间件：实现 NestMiddleware 接口，并用 @Injectable() 装饰器标记。例如：

   @Injectable()
   export class LoggerMiddleware implements NestMiddleware {
     use(req: Request, res: Response, next: Function) {
       console.log(`Request...`);
       next();
     }
   }

2. 注册中间件：在模块中通过 configure() 方法使用 MiddlewareConsumer 将中间件应用到指定路由或所有路由：

   export class AppModule implements NestModule {
     configure(consumer: MiddlewareConsumer) {
       consumer.apply(LoggerMiddleware).forRoutes('*');
     }
   }

这种方式使得在请求到达控制器前可以统一进行处理。

NestJS 中的模块（Module）有什么作用？如何组织应用？

模块是 NestJS 应用的基本组织单元，用于封装和分离相关功能。

• 作用：
  • 将控制器、服务、提供者等封装在一起，形成独立的业务逻辑块；
  • 通过 imports、controllers、providers 和 exports 属性来管理依赖和暴露接口。
• 组织方式：
  • 每个模块负责一块业务，比如用户模块、订单模块等；
  • 主模块（如 AppModule）引入其他子模块，实现整体功能的组合和解耦。
    这种模块化设计使代码结构更清晰，便于团队协作和后期维护。

解释 @Module 装饰器的四个核心属性

@Module({
  imports: [/* 其他依赖模块 */],  // 引入外部模块（如 DatabaseModule）
  controllers: [/* 控制器 */],    // 定义路由处理类
  providers: [/* 服务/提供者 */], // 业务逻辑和可注入类
  exports: [/* 暴露的服务 */]     // 允许其他模块复用本模块服务
})

如何在 NestJS 中创建和使用控制器（Controller）和服务（Service）？

在 NestJS 中，控制器负责接收 HTTP 请求并返回响应，而服务封装具体业务逻辑。

• 创建控制器：
  • 使用 @Controller() 装饰器定义一个类；
  • 通过路由装饰器（如 @Get()、@Post()）来映射 HTTP 方法和路径。例如：

    @Controller('users')
    export class UsersController {
      constructor(private readonly usersService: UsersService) {}
      
      @Get()
      async findAll() {
        return await this.usersService.findAll();
      }
    }

• 创建服务：
  • 使用 @Injectable() 装饰器标记服务类；
  • 在服务中实现具体的业务逻辑，然后在控制器中注入使用。
    这种分层设计有助于职责分离，使代码更易于测试和维护。

什么是管道（Pipes）？如何使用？

管道用于在数据进入控制器前对其进行转换和验证。

• 功能：
  • 数据转换：例如将字符串转换为数字；
  • 数据验证：检查传入的数据是否符合预期格式。
• 使用方式：
  • 实现 PipeTransform 接口，并通过 @Injectable() 装饰器创建自定义管道；
  • 也可直接使用 NestJS 内置的管道，如 ValidationPipe。
    例如：

  @UsePipes(new ValidationPipe())
  @Post()
  create(@Body() createUserDto: CreateUserDto) {
    // 创建用户逻辑
  }

这样确保了传入的数据合法且格式正确，简化了控制器内的参数处理。

什么是守卫（Guards）？如何在 NestJS 中实现认证和授权？

守卫用于在请求处理之前判断当前请求是否具有访问权限，常用于认证和授权。

• 作用：
  • 判断请求是否满足某些条件（如是否登录、角色是否匹配等）；
  • 决定请求是否可以进入下一个处理环节。
• 实现方法：
  • 实现 CanActivate 接口，并使用 @Injectable() 装饰器。例如：

    @Injectable()
    export class AuthGuard implements CanActivate {
      canActivate(context: ExecutionContext): boolean {
        const request = context.switchToHttp().getRequest();
        const token = request.headers.authorization;
        // 验证 token 的逻辑
        return isValid; // 根据验证结果返回 true 或 false
      }
    }

  • 通过 @UseGuards(AuthGuard) 装饰器将守卫应用到控制器或具体路由。
    这种机制能够在进入业务逻辑前有效拦截非法请求，保障系统安全。

---

NestJS 的拦截器（Interceptors）有什么作用？

拦截器可在方法执行的前后加入额外逻辑，例如响应转换、日志记录、缓存处理等。

• 主要用途：
  • 响应转换：对返回结果进行统一包装或格式调整；
  • 日志记录：记录方法执行前后的信息；
  • 异常处理：捕获并处理异常。
• 示例代码：

  @Injectable()
  export class TransformInterceptor<T> implements NestInterceptor<T, any> {
    intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
      return next.handle().pipe(map(data => ({ data })));
    }
  }

  通过 @UseInterceptors() 装饰器可以将拦截器应用到控制器或具体路由，实现对响应数据的统一格式化。

---

如何用 Interceptor 统一封装响应格式？

@Injectable()
export class TransformInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler) {
    return next.handle().pipe(
      map(data => ({
        code: 200,
        success: true,
        data,
        timestamp: new Date().getTime()
      }))
    );
  }
}
// 通过 @UseInterceptors 注解或全局注册

中间件和拦截器的区别与使用场景

特性	中间件 (Middleware)	拦截器 (Interceptor)
执行阶段	路由处理前（甚至未命中路由）	请求处理前后（已绑定路由）
典型场景	日志、CORS、请求体压缩	统一响应格式、异常映射、缓存处理
数据访问	只能访问请求/响应对象	可获取执行上下文、控制器方法元数据

NestJS 如何支持异常处理（Exception handling）？

NestJS 内置了异常处理机制，可以捕获并处理运行时的错误，返回统一格式的错误响应。

• 默认机制：
  • 框架内置的异常过滤器会自动捕获常见错误并返回标准 HTTP 响应。
• 自定义异常过滤器：
  • 开发者可以实现 ExceptionFilter 接口，并使用 @Catch() 装饰器捕获特定类型的异常。例如：

    @Catch(HttpException)
    export class HttpExceptionFilter implements ExceptionFilter {
      catch(exception: HttpException, host: ArgumentsHost) {
        const ctx = host.switchToHttp();
        const response = ctx.getResponse<Response>();
        const status = exception.getStatus();
        response.status(status).json({
          statusCode: status,
          message: exception.message,
        });
      }
    }

  • 然后通过 @UseFilters(HttpExceptionFilter) 应用到控制器或全局。
    这种机制有助于统一错误处理，改善用户体验和调试效率。

如何实现全局异常处理

// 自定义异常过滤器
@Catch(HttpException)
export class AllExceptionsFilter implements ExceptionFilter {
  catch(exception: HttpException, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse<Response>();
    const status = exception.getStatus();

    response.status(status).json({
      code: status,
      message: exception.message,
      timestamp: new Date().toISOString()
    });
  }
}

// 在 main.ts 全局注册
app.useGlobalFilters(new AllExceptionsFilter());

如何使用 NestJS 实现微服务架构？

NestJS 内置了微服务支持，通过多种传输层协议构建分布式应用。

• 实现方式：
  • 使用 NestFactory.createMicroservice() 方法创建微服务实例；
  • 定义消息模式（pattern），通过 @MessagePattern() 装饰器来监听消息；
  • 使用 @Client() 装饰器创建微服务客户端，与其他服务进行通信。
• 示例代码：

  @Controller()
  export class AppController {
    constructor(@Inject('MATH_SERVICE') private client: ClientProxy) {}
    
    @MessagePattern({ cmd: 'sum' })
    accumulate(data: number[]): number {
      return (data || []).reduce((a, b) => a + b);
    }
  }

  • 不同微服务间可以通过 TCP、Redis、MQTT 等协议进行通信，实现功能解耦和扩展。
    这种方式适合构建高并发、可伸缩的大型分布式系统。

微服务架构中，NestJS 如何与前端协作

• 通信协议：使用 TCP、Redis、MQTT 或 WebSocket（适合实时前端更新）
• API 网关：聚合微服务接口，提供前端统一的 REST/GraphQL 入口
• 序列化：通过 class-transformer 规范微服务间数据传输格式
• 前端优化：结合 BFF 模式，由 Nest 微服务处理聚合逻辑，减少前端请求复杂度

如何用 Swagger 生成 API 文档

1. 安装 @nestjs/swagger
2. 在 main.ts 初始化：

const config = new DocumentBuilder()
  .setTitle('API Docs')
  .setVersion('1.0')
  .build();
const document = SwaggerModule.createDocument(app, config);
SwaggerModule.setup('api', app, document);

3. 使用 @ApiProperty() 装饰 DTO，@ApiOperation() 描述接口

如何优化 NestJS 应用启动速度？

• 懒加载模块：@Module({ imports: [LazyModule.forRoot()] })
• 压缩依赖：检查 imports 是否包含不必要的模块
• 启用 Cluster：利用多核 CPU（nestjs/cluster）
• 缓存编译：生产环境使用 webpack 缓存（nest build --webpack）

如何设计 NestJS 项目目录结构？

src/
├── common/          // 公共模块（装饰器、过滤器）
├── config/          // 配置文件
├── modules/         // 业务模块
│   └── user/
│       ├── dto/     // 数据验证对象
│       ├── entities/ // 数据库实体
│       ├── user.controller.ts
│       ├── user.module.ts
│       └── user.service.ts
├── shared/          // 全局共享（数据库、Redis）
└── main.ts          // 入口文件

原则：模块按功能垂直拆分，公用资源水平抽象，严格分层控制依赖方向