罗罗编程学习记录
本页内容 展开查看

04.2.3.1 NestJS 核心机制

所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.2 Node.js / 04.2.3 NestJS

覆盖范围

  • 模块系统:@Module、Controller、Provider
  • 依赖注入:构造函数注入、Scope(默认单例)
  • 守卫:权限校验,在路由处理前执行
  • 拦截器:在路由处理前后加逻辑,日志、超时、响应转换
  • 管道:参数校验和转换,DTO 校验
  • 异常过滤器:统一错误处理

高频题速览

编号 题目 难度 频率
04.2.3.1-001 NestJS 的模块和控制器 进阶 ★★★★☆
04.2.3.1-002 依赖注入原理 进阶 ★★★★☆
04.2.3.1-003 守卫是干什么的 进阶 ★★★★☆
04.2.3.1-004 拦截器和中间件区别 进阶 ★★★★☆
04.2.3.1-005 管道是干什么的 进阶 ★★★★☆
04.2.3.1-006 NestJS 请求生命周期 高级 ★★★★☆
04.2.3.1-007 Provider 有哪些类型 进阶 ★★★☆☆
04.2.3.1-008 异常过滤器怎么用 进阶 ★★★☆☆

04.2.3.1-001 NestJS 的模块系统是什么?

频率 ★★★★☆ | 难度 进阶

一句话结论

NestJS 用模块组织代码:@Module 装饰器声明模块,每个模块包含控制器(Controller)、服务(Provider)、导入的其他模块、导出的服务;模块是 NestJS 组织代码的基本单元。

概念解释

  • @Module:模块装饰器,标记一个类是 NestJS 模块。
  • controllers:这个模块的控制器,处理 HTTP 请求。
  • providers:这个模块的服务,被 Nest 容器管理。
  • imports:导入其他模块,用其他模块导出的服务。
  • exports:导出这个模块的服务,其他模块导入后可以用。
  • 特点:模块是单例的,默认整个应用只有一个实例。

原理流程

  1. 应用启动时,NestJS 根模块(AppModule)开始加载。
  2. 根模块 imports 里声明的子模块也被加载。
  3. 每个模块的 providers 被实例化,放到依赖注入容器里。
  4. 控制器的路由被注册到 HTTP 服务器。

代码 / 示例

// 用户模块
@Module({
  controllers: [UserController],
  providers: [UserService],
  exports: [UserService], // 导出 UserService,其他模块导入后可以用
  imports: [TypeOrmModule.forFeature([User])], // 导入 TypeORM 模块
})
export class UserModule {}

// 订单模块
@Module({
  controllers: [OrderController],
  providers: [OrderService],
  imports: [UserModule], // 导入 UserModule,可以用 UserService
})
export class OrderModule {}

// 根模块
@Module({
  imports: [UserModule, OrderModule],
})
export class AppModule {}

常见误区

  • 误区:模块之间可以随便用服务?正解:服务必须 exports 出来,其他模块 import 了这个模块才能用。
  • 误区:模块每次请求都新建?正解:模块是单例的,整个应用只有一个实例。

追问 / 延伸

  • 什么是全局模块?答:@Global() 装饰的模块,不用 import 就能用,比如数据库模块。
  • 什么是动态模块?答:可以传入参数的模块,比如 ConfigModule.forRoot({...})。

04.2.3.1-002 NestJS 依赖注入的原理是什么?

频率 ★★★★☆ | 难度 进阶

一句话结论

NestJS 在启动时扫描所有 Provider,根据构造函数参数类型,自动实例化并注入依赖;用 TypeScript 的类型反射拿到参数类型,从容器里取对应的实例注入。

概念解释

  • 依赖注入(DI):不自己 new 对象,由容器自动注入。
  • Nest 容器:管理所有 Provider 的实例,是一个 IoC 容器。
  • 构造函数注入:在构造函数里声明依赖,Nest 自动注入。
  • 原理:用 TypeScript 的 emitDecoratorMetadata 拿到构造函数参数的类型,从容器里取实例。

原理流程

  1. 启动时,NestJS 扫描所有 @Injectable() 标记的类。
  2. 读构造函数的参数类型(通过装饰器元数据)。
  3. 如果参数对应的 Provider 还没实例化,就实例化它。
  4. 把实例传给构造函数,创建当前类的实例。
  5. 所有实例都放到容器里,其他地方需要时直接取。

代码 / 示例

@Injectable()
export class UserService {
  constructor(
    private readonly userRepository: UserRepository, // 自动注入
    private readonly configService: ConfigService,   // 自动注入
  ) {}
}

// 不需要手动 new,Nest 自动处理
@Controller('users')
export class UserController {
  constructor(private readonly userService: UserService) {}
}

常见误区

  • 误区:依赖注入就是 new 对象?正解:DI 是容器帮你管理对象,你只声明依赖,容器自动创建和注入。
  • 误区:TypeScript 类型在运行时还在?正解:TypeScript 类型编译后就没了,NestJS 用 emitDecoratorMetadata 把类型信息存到装饰器元数据里。

追问 / 延伸

  • 什么是 Scope?答:Provider 的生命周期,默认单例(SINGLETON),还有 REQUEST(每个请求一个)、TRANSIENT(每次注入一个)。
  • 什么是循环依赖?答:A 依赖 B,B 依赖 A,Nest 启动时会报错,要用 forwardRef 解决。

04.2.3.1-003 守卫是干什么的?

频率 ★★★★☆ | 难度 进阶

一句话结论

守卫(Guard)在路由处理之前执行,用来做权限校验,返回 true 就放行,返回 false 就返回 403;守卫是 NestJS 做权限控制的主要方式。

概念解释

  • 守卫:实现 CanActivate 接口,有一个 canActivate 方法。
  • 执行时机:在路由处理器之前,在中间件之后。
  • 返回 true:请求继续往下走。
  • 返回 false:抛出 ForbiddenException,返回 403。
  • 用途:权限校验、角色检查、登录状态检查。

原理流程

  1. 请求进来,先过中间件。
  2. 然后过守卫,守卫检查用户有没有权限访问这个路由。
  3. 守卫返回 true,继续过拦截器、管道,最后到路由处理器。
  4. 守卫返回 false,直接返回 403,不执行后面的逻辑。

代码 / 示例

@Injectable()
export class AuthGuard implements CanActivate {
  constructor(private readonly jwtService: JwtService) {}

  canActivate(context: ExecutionContext): boolean {
    const request = context.switchToHttp().getRequest();
    const token = request.headers.authorization?.replace('Bearer ', '');

    if (!token) {
      throw new UnauthorizedException('未登录');
    }

    try {
      const payload = this.jwtService.verify(token);
      request.user = payload;
      return true; // 放行
    } catch {
      throw new UnauthorizedException('token 无效');
    }
  }
}

// 使用:在控制器或路由上挂守卫
@Controller('users')
@UseGuards(AuthGuard)
export class UserController {
  // ...
}

常见误区

  • 误区:守卫和中间件一样?正解:中间件是 Express 层的,守卫是 Nest 层的,守卫可以拿到路由元数据(比如 @Roles('admin')),中间件拿不到。
  • 误区:守卫只能做登录校验?正解:守卫可以做任何权限相关的校验,角色、权限、IP 白名单都可以。

追问 / 延伸

  • 守卫和拦截器有什么区别?答:守卫只在路由前执行,用来做权限判断;拦截器在路由前后都执行,用来加日志、改响应。
  • 什么是路由元数据?答:用 @SetMetadata('roles', ['admin']) 给路由打标签,守卫里读这个标签判断权限。

04.2.3.1-004 拦截器和中间件有什么区别?

频率 ★★★★☆ | 难度 进阶

一句话结论

中间件是 Express 层的,在请求进入 Nest 之前执行;拦截器是 Nest 层的,在路由处理前后都能执行,可以修改请求和响应;中间件拿不到路由信息,拦截器可以。

概念解释

  • 中间件(Middleware):
    • Express 层,请求进来最先执行。
    • 可以修改 request/response。
    • 拿不到路由信息(不知道要调哪个控制器方法)。
    • 用途:日志、CORS、请求 ID 生成。
  • 拦截器(Interceptor):
    • Nest 层,在路由前后执行。
    • 可以修改请求和响应。
    • 可以拿到路由信息(执行上下文)。
    • 用途:日志、超时、响应转换、缓存。

原理流程

  1. 请求进来,先过 Express 中间件。
  2. 然后过 Nest 守卫。
  3. 然后过拦截器的前置部分。
  4. 然后过管道,到路由处理器。
  5. 路由处理器返回,过拦截器的后置部分。
  6. 然后过异常过滤器,最后返回响应。

代码 / 示例

// 拦截器示例:记录每个请求的耗时
@Injectable()
export class LoggingInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    const request = context.switchToHttp().getRequest();
    const startTime = Date.now();

    return next.handle().pipe(
      tap(() => {
        const duration = Date.now() - startTime;
        console.log(`${request.method} ${request.url} - ${duration}ms`);
      }),
    );
  }
}

// 中间件示例:生成请求 ID
@Injectable()
export class RequestIdMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: Function) {
    req.requestId = uuidv4();
    next();
  }
}

常见误区

  • 误区:拦截器和中间件是一回事?正解:中间件在 Express 层,拦截器在 Nest 层,执行时机不同,能力也不同。
  • 误区:拦截器只能在路由前执行?正解:拦截器可以在路由前后都执行,用 RxJS 的 tap、map、catchError 操作符。

追问 / 延伸

  • 拦截器和 AOP 是什么关系?答:拦截器就是 NestJS 的 AOP 实现,在不修改业务代码的情况下,给方法加日志、加监控。
  • 什么是响应转换?答:拦截器可以把路由返回的对象统一包成 { code: 0, data: ..., message: 'ok' } 的格式。

04.2.3.1-005 管道是干什么的?

频率 ★★★★☆ | 难度 进阶

一句话结论

管道(Pipe)在路由处理器之前执行,用来做参数转换和校验,比如把字符串转成数字,或者校验 DTO 的字段是否符合要求;NestJS 内置了 ValidationPipe,配合 class-validator 做自动校验。

概念解释

  • 管道:实现 PipeTransform 接口,有一个 transform 方法。
  • 执行时机:在守卫之后,路由处理器之前。
  • 用途:
    • 参数转换:字符串转数字、字符串转枚举。
    • 参数校验:校验请求体、查询参数是否符合要求。
  • 内置管道:ValidationPipe、ParseIntPipe、ParseUUIDPipe。

原理流程

  1. 请求进来,过守卫。
  2. 然后过管道,管道把请求参数转换成目标类型。
  3. 如果校验不通过,抛出 BadRequestException,返回 400。
  4. 校验通过,把参数传给路由处理器。

代码 / 示例

// DTO:数据传输对象
export class CreateUserDto {
  @IsString()
  @MinLength(2)
  name: string;

  @IsEmail()
  email: string;

  @IsInt()
  @Min(0)
  age: number;
}

// 控制器
@Post()
@UsePipes(new ValidationPipe())
createUser(@Body() dto: CreateUserDto) {
  // dto 已经校验过了,name 一定是字符串,email 一定是邮箱格式
  return this.userService.create(dto);
}

// 全局管道
async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.useGlobalPipes(new ValidationPipe({
    transform: true, // 自动把请求体转成 DTO 类的实例
    whitelist: true, // 过滤掉 DTO 里没声明的字段
  }));
  await app.listen(3000);
}

常见误区

  • 误区:管道和拦截器是一回事?正解:管道在路由前执行,主要做参数转换和校验;拦截器在路由前后都能执行,主要做日志和响应转换。
  • 误区:要手动写校验代码?正解:用 class-validator 装饰器,ValidationPipe 自动校验,不用手动写 if 判断。

追问 / 延伸

  • 什么是 whitelist?答:请求体里如果有 DTO 没声明的字段,自动过滤掉,防止多余字段。
  • 什么是 transform?答:自动把请求体的普通对象转成 DTO 类的实例,这样 DTO 里的方法和装饰器才能用。

04.2.3.1-006 NestJS 的请求生命周期是怎样的?

频率 ★★★★☆ | 难度 高级

一句话结论

请求生命周期:中间件 → 守卫 → 拦截器(前置)→ 管道 → 路由处理器 → 拦截器(后置)→ 异常过滤器 → 响应;每个阶段各司其职,出问题在对应阶段调试。

概念解释

执行顺序:

  1. 中间件(Middleware):Express 层,最先执行。
  2. 守卫(Guard):权限校验。
  3. 拦截器(Interceptor):前置部分。
  4. 管道(Pipe):参数转换和校验。
  5. 路由处理器(Controller):业务逻辑。
  6. 拦截器(Interceptor):后置部分。
  7. 异常过滤器(Exception Filter):捕获异常。

原理流程

  1. 请求进来,先过 Express 中间件(比如 CORS、日志)。
  2. 然后过 Nest 守卫,检查有没有权限。
  3. 然后过拦截器的前置部分(比如记录请求开始时间)。
  4. 然后过管道,把参数转换和校验。
  5. 然后到路由处理器,执行业务逻辑。
  6. 路由处理器返回,过拦截器的后置部分(比如记录耗时、修改响应)。
  7. 如果中间任何一步抛异常,过异常过滤器,转成错误响应。

代码 / 示例

// 全局注册
app.useGlobalMiddlewares(RequestIdMiddleware);
app.useGlobalGuards(AuthGuard);
app.useGlobalInterceptors(LoggingInterceptor);
app.useGlobalPipes(new ValidationPipe());
app.useGlobalFilters(AllExceptionsFilter);

常见误区

  • 误区:管道在守卫之前执行?正解:守卫在管道之前,因为要先判断有没有权限,再校验参数。
  • 误区:拦截器只能在路由前执行?正解:拦截器前后都能执行,next.handle() 后面就是路由执行完的逻辑。

追问 / 延伸

  • 什么是执行上下文?答:ExecutionContext 对象,包含当前请求的信息,能拿到 request、response、控制器、方法名,守卫和拦截器都能拿到。
  • 为什么要分这么多层?答:每层职责单一,中间件做通用处理,守卫做权限,管道做参数,拦截器做 AOP,职责清晰。

04.2.3.1-008 异常过滤器怎么用?

频率 ★★★☆☆ | 难度 进阶

一句话结论

异常过滤器(Exception Filter)统一处理所有抛出的异常,把异常转成统一格式的 JSON 响应,不用在每个控制器里 try-catch。

概念解释

  • 异常过滤器:实现 ExceptionFilter 接口,有一个 catch 方法。
  • 作用:捕获所有异常,统一格式化返回。
  • 全局注册后,所有抛出的异常都过这个过滤器。

原理流程

  1. 业务代码抛异常(比如 NotFoundException、BadRequestException)。
  2. 异常过滤器捕获到这个异常。
  3. 根据异常类型,返回对应的 HTTP 状态码和 JSON 格式。
  4. 不用每个控制器都写 try-catch。

代码 / 示例

@Catch()
export class AllExceptionsFilter implements ExceptionFilter {
  catch(exception: unknown, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse();
    const request = ctx.getRequest();

    const status = exception instanceof HttpException
      ? exception.getStatus()
      : 500;

    response.status(status).json({
      code: status,
      message: exception instanceof Error ? exception.message : '服务器内部错误',
      path: request.url,
      timestamp: new Date().toISOString(),
    });
  }
}

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

常见误区

  • 误区:所有异常都要手动 try-catch?正解:抛异常就行,异常过滤器统一处理,业务代码更干净。
  • 误区:异常过滤器能捕获所有错误?正解:同步代码的异常都能捕获,异步代码的错误要用 RxJS 的 catchError。

追问 / 延伸

  • NestJS 内置了哪些异常?答:BadRequestException、UnauthorizedException、ForbiddenException、NotFoundException、ConflictException 等。
  • 什么是异常层级?答:HttpException 是基类,其他异常都继承它,都有 getStatus() 方法。

待整理清单

  • [ ] NestJS 微服务与 GraphQL
  • [ ] NestJS 配置与环境变量
  • [ ] NestJS 测试策略(单元测试、E2E 测试)
  • [ ] NestJS 循环依赖与 forwardRef