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:导出这个模块的服务,其他模块导入后可以用。
- 特点:模块是单例的,默认整个应用只有一个实例。
原理流程
- 应用启动时,NestJS 根模块(AppModule)开始加载。
- 根模块 imports 里声明的子模块也被加载。
- 每个模块的 providers 被实例化,放到依赖注入容器里。
- 控制器的路由被注册到 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 拿到构造函数参数的类型,从容器里取实例。
原理流程
- 启动时,NestJS 扫描所有 @Injectable() 标记的类。
- 读构造函数的参数类型(通过装饰器元数据)。
- 如果参数对应的 Provider 还没实例化,就实例化它。
- 把实例传给构造函数,创建当前类的实例。
- 所有实例都放到容器里,其他地方需要时直接取。
代码 / 示例
@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。
- 用途:权限校验、角色检查、登录状态检查。
原理流程
- 请求进来,先过中间件。
- 然后过守卫,守卫检查用户有没有权限访问这个路由。
- 守卫返回 true,继续过拦截器、管道,最后到路由处理器。
- 守卫返回 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 层,在路由前后执行。
- 可以修改请求和响应。
- 可以拿到路由信息(执行上下文)。
- 用途:日志、超时、响应转换、缓存。
原理流程
- 请求进来,先过 Express 中间件。
- 然后过 Nest 守卫。
- 然后过拦截器的前置部分。
- 然后过管道,到路由处理器。
- 路由处理器返回,过拦截器的后置部分。
- 然后过异常过滤器,最后返回响应。
代码 / 示例
// 拦截器示例:记录每个请求的耗时
@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。
原理流程
- 请求进来,过守卫。
- 然后过管道,管道把请求参数转换成目标类型。
- 如果校验不通过,抛出 BadRequestException,返回 400。
- 校验通过,把参数传给路由处理器。
代码 / 示例
// 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 的请求生命周期是怎样的?
频率 ★★★★☆ | 难度 高级
一句话结论
请求生命周期:中间件 → 守卫 → 拦截器(前置)→ 管道 → 路由处理器 → 拦截器(后置)→ 异常过滤器 → 响应;每个阶段各司其职,出问题在对应阶段调试。
概念解释
执行顺序:
- 中间件(Middleware):Express 层,最先执行。
- 守卫(Guard):权限校验。
- 拦截器(Interceptor):前置部分。
- 管道(Pipe):参数转换和校验。
- 路由处理器(Controller):业务逻辑。
- 拦截器(Interceptor):后置部分。
- 异常过滤器(Exception Filter):捕获异常。
原理流程
- 请求进来,先过 Express 中间件(比如 CORS、日志)。
- 然后过 Nest 守卫,检查有没有权限。
- 然后过拦截器的前置部分(比如记录请求开始时间)。
- 然后过管道,把参数转换和校验。
- 然后到路由处理器,执行业务逻辑。
- 路由处理器返回,过拦截器的后置部分(比如记录耗时、修改响应)。
- 如果中间任何一步抛异常,过异常过滤器,转成错误响应。
代码 / 示例
// 全局注册
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 方法。
- 作用:捕获所有异常,统一格式化返回。
- 全局注册后,所有抛出的异常都过这个过滤器。
原理流程
- 业务代码抛异常(比如 NotFoundException、BadRequestException)。
- 异常过滤器捕获到这个异常。
- 根据异常类型,返回对应的 HTTP 状态码和 JSON 格式。
- 不用每个控制器都写 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