当前位置：首页 > news >正文

NestJS 是基于 Node.js 的渐进式后端框架，核心特点包括依赖注入、模块化架构、装饰器驱动、TypeScript 优先、与主流工具集成等

news 2025/11/9 11:21:06

NestJS 是基于 Node.js 的渐进式后端框架，核心特点包括 依赖注入、模块化架构、装饰器驱动、TypeScript 优先、与主流工具集成 等。以下通过代码示例，直观展示其核心特点：

一、TypeScript 优先（强类型支持）

NestJS 原生支持 TypeScript，类型定义清晰，减少运行时错误：

// src/user/dto/create-user.dto.ts（数据传输对象，强类型校验）
import { IsString, IsEmail, MinLength } from 'class-validator';export class CreateUserDto {@IsString() // 校验字段类型为字符串name: string;@IsEmail() // 校验邮箱格式email: string;@MinLength(6) // 密码最小长度 6password: string;
}

二、模块化架构（Module）

Nest 用 Module 组织代码，实现功能解耦，每个模块包含控制器、服务等：

// src/user/user.module.ts
import { Module } from '@nestjs/common';
import { UserController } from './user.controller';
import { UserService } from './user.service';@Module({controllers: [UserController], // 注册控制器（处理请求）providers: [UserService],      // 注册服务（业务逻辑）exports: [UserService],        // 导出服务，供其他模块使用
})
export class UserModule {}// src/app.module.ts（根模块，入口）
import { Module } from '@nestjs/common';
import { UserModule } from './user/user.module';@Module({imports: [UserModule], // 导入子模块
})
export class AppModule {}

三、装饰器驱动（Controller + Route）

用装饰器快速定义路由、请求方法、参数绑定，语法简洁：

// src/user/user.controller.ts（控制器：处理 HTTP 请求）
import { Controller, Get, Post, Body, Param, Query } from '@nestjs/common';
import { UserService } from './user.service';
import { CreateUserDto } from './dto/create-user.dto';@Controller('users') // 基础路由：/users
export class UserController {constructor(private readonly userService: UserService) {}// POST /users （创建用户，自动校验 CreateUserDto）@Post()create(@Body() createUserDto: CreateUserDto) {return this.userService.create(createUserDto);}// GET /users （查询所有用户，支持分页参数）@Get()findAll(@Query('page') page = 1, @Query('limit') limit = 10) {return this.userService.findAll({ page, limit });}// GET /users/:id （查询单个用户，路径参数绑定）@Get(':id')findOne(@Param('id') id: string) {return this.userService.findOne(+id); // 转换为数字}
}

四、依赖注入（DI）

Nest 内置依赖注入容器，解耦组件依赖，便于测试和维护：

// src/user/user.service.ts（服务：封装业务逻辑）
import { Injectable } from '@nestjs/common';
import { CreateUserDto } from './dto/create-user.dto';// @Injectable() 标记为可注入的服务，供控制器/其他服务依赖
@Injectable()
export class UserService {private users = []; // 模拟数据库create(createUserDto: CreateUserDto) {const user = { id: Date.now(), ...createUserDto };this.users.push(user);return user;}findAll({ page, limit }) {const start = (page - 1) * limit;return this.users.slice(start, start + limit);}findOne(id: number) {return this.users.find(user => user.id === id);}
}// 控制器中自动注入 UserService（无需手动实例化）
// constructor(private readonly userService: UserService) {}

五、中间件（Middleware）

拦截请求/响应，实现日志、认证等通用逻辑：

// src/logging.middleware.ts
import { Injectable, NestMiddleware } from '@nestjs/common';
import { Request, Response, NextFunction } from 'express';@Injectable()
export class LoggingMiddleware implements NestMiddleware {use(req: Request, res: Response, next: NextFunction) {console.log(`[${new Date().toISOString()}] ${req.method} ${req.originalUrl}`);next(); // 继续执行后续逻辑}
}// 在模块中注册中间件
// src/app.module.ts
import { Module, NestModule, MiddlewareConsumer } from '@nestjs/common';@Module({ imports: [UserModule] })
export class AppModule implements NestModule {configure(consumer: MiddlewareConsumer) {consumer.apply(LoggingMiddleware) // 应用中间件.forRoutes('users'); // 对 /users 路由生效（可指定控制器/通配符）}
}

六、守卫（Guard）

权限控制，决定请求是否能进入控制器：

// src/auth.guard.ts（认证守卫）
import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';@Injectable()
export class AuthGuard implements CanActivate {canActivate(context: ExecutionContext): boolean {const request = context.switchToHttp().getRequest();return !!request.headers.authorization; // 简单校验是否有 Authorization 头}
}// 在控制器/路由上使用
import { UseGuards } from '@nestjs/common';
import { AuthGuard } from '../auth.guard';@Controller('users')
@UseGuards(AuthGuard) // 整个控制器需要认证
export class UserController {// 或单独对某个路由生效@Get(':id')@UseGuards(AuthGuard)findOne(@Param('id') id: string) { ... }
}

七、拦截器（Interceptor）

处理请求/响应转换、异常捕获、超时控制等：

// src/transform.interceptor.ts（响应格式化）
import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
import { Observable } from 'rxjs';
import { map } from 'rxjs/operators';// 统一响应格式：{ data: ..., success: true }
export interface Response<T> {data: T;success: boolean;
}@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,success: true,})),);}
}// 全局注册（所有响应生效）
// src/main.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { TransformInterceptor } from './transform.interceptor';async function bootstrap() {const app = await NestFactory.create(AppModule);app.useGlobalInterceptors(new TransformInterceptor());await app.listen(3000);
}
bootstrap();

八、异常过滤器（Exception Filter）

统一异常处理，自定义错误响应格式：

// src/http-exception.filter.ts
import { ExceptionFilter, Catch, ArgumentsHost, HttpException } from '@nestjs/common';
import { Request, Response } from 'express';@Catch(HttpException) // 捕获 HttpException 及其子类
export class HttpExceptionFilter implements ExceptionFilter {catch(exception: HttpException, host: ArgumentsHost) {const ctx = host.switchToHttp();const response = ctx.getResponse<Response>();const request = ctx.getRequest<Request>();const status = exception.getStatus();response.status(status).json({statusCode: status,message: exception.getResponse(),path: request.url,timestamp: new Date().toISOString(),});}
}// 全局注册
// src/main.ts
import { HttpExceptionFilter } from './http-exception.filter';async function bootstrap() {const app = await NestFactory.create(AppModule);app.useGlobalFilters(new HttpExceptionFilter());await app.listen(3000);
}

核心特点总结

特点	说明
TypeScript 优先	强类型支持，提升代码可读性和可维护性
模块化架构	按功能拆分模块，解耦清晰
依赖注入	自动管理组件依赖，便于测试和扩展
装饰器驱动	简化路由、中间件、守卫等配置
丰富的扩展点	中间件、守卫、拦截器、过滤器等
生态集成	无缝对接 Express/Fastify、TypeORM/Mongoose、JWT 等