通过简单项目演示nestjs功能概念

NestJS 的设计哲学是模块化、可扩展和易于维护。它通过提供一系列强大的功能层，如中间件、过滤器、管道、守卫和拦截器，来帮助开发者精细地控制请求的生命周期。理解它们各自的职责和执行顺序，对于构建健壮的 NestJS 应用至关重要。

让我们一步步来拆解这些功能，并用一个**“博客文章管理”项目**的例子来具体说明它们的场景。

---

NestJS 请求处理流程概览

在深入每个功能之前，先了解一个请求在 NestJS 中大致会经历哪些阶段，这有助于理解它们各自的位置：

1. 传入请求 (Raw HTTP Request)
2. 中间件 (Middleware)
3. 守卫 (Guards) - 身份验证/授权
4. 拦截器 (Interceptors) - 前置处理 (请求包装, 日志计时等)
5. 管道 (Pipes) - 参数验证/转换
6. 控制器/路由处理函数 (Controller Handler) - 业务逻辑执行
7. 拦截器 (Interceptors) - 后置处理 (响应转换, 缓存等)
8. 异常过滤器 (Exception Filters) - 异常处理
9. 发送响应 (HTTP Response)

---

1. 中间件 (Middleware)

• 类比： 类似于进入大厦前的安检，或者日志记录员，它在请求到达 NestJS 核心路由处理之前执行。
• 执行时机： 最早。在路由处理之前，甚至在守卫、管道等之前。它和 Express 的中间件概念非常相似。
• 作用：
  • 执行与特定路由无关的通用逻辑。
  • 修改请求 (req) 或响应 (res) 对象。
  • 日志记录、CORS 处理、请求体解析（例如 body-parser）。
  • 简单的身份验证（例如检查 Authorization 头，但不做授权判断）。
• 场景举例 (博客文章管理)：
  • 请求日志记录： 记录所有进入系统的 HTTP 请求的 URL、方法、时间戳等信息。
  • API 密钥验证： 验证请求头中是否存在有效的 API Key，如果不存在直接拒绝。
  • CORS 设置： 全局设置跨域资源共享头。

// src/common/middleware/logger.middleware.ts
import { Injectable, NestMiddleware } from '@nestjs/common';
import { Request, Response, NextFunction } from 'express';
 
@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: NextFunction) {
    console.log(`[${new Date().toISOString()}] Request: ${req.method} ${req.originalUrl}`);
    next(); // 调用 next() 将控制权传递给下一个中间件或路由处理程序
  }
}
 
// src/app.module.ts (应用)
import { Module, MiddlewareConsumer, RequestMethod } from '@nestjs/common';
import { LoggerMiddleware } from './common/middleware/logger.middleware';
 
@Module({ /* ... */ })
export class AppModule {
  configure(consumer: MiddlewareConsumer) {
    consumer
      .apply(LoggerMiddleware)
      .forRoutes('*'); // 应用于所有路由
  }
}

---

2. 守卫 (Guards)

• 类比： VIP 区域的入口守卫，他会检查你的身份（是否登录）和权限（是否有权进入），如果不足格则拒绝。
• 执行时机： 在中间件之后，但在任何拦截器或管道之前，业务逻辑处理之前。
• 作用： 主要用于授权 (Authorization)。判断当前请求是否被允许执行（例如，用户是否有权限访问某个资源或执行某个操作）。
• 场景举例 (博客文章管理)：
  • JWT 身份验证： 验证用户请求中携带的 JWT Token 是否有效，并解析出用户信息（如用户ID、角色），以便后续授权判断。如果 Token 无效，直接抛出 Unauthorized 错误。
  • 角色权限检查： 判断当前登录用户是否具备修改文章（update-article）或删除评论（delete-comment）的权限。

// src/common/guards/auth.guard.ts
import { Injectable, CanActivate, ExecutionContext, UnauthorizedException } from '@nestjs/common';
import { Observable } from 'rxjs';
// 假设这里有一个 JWT 验证服务
import { JwtService } from '@nestjs/jwt'; // 只是示例，实际可能在 AuthModule 中
 
@Injectable()
export class AuthGuard implements CanActivate {
  constructor(private jwtService: JwtService) {} // 实际可能通过模块提供
 
  canActivate(context: ExecutionContext): boolean | Promise<boolean> | Observable<boolean> {
    const request = context.switchToHttp().getRequest();
    const authHeader = request.headers.authorization;
 
    if (!authHeader || !authHeader.startsWith('Bearer ')) {
      throw new UnauthorizedException('Authorization token not found or malformed.');
    }
 
    const token = authHeader.split(' ')[1];
    try {
      const payload = this.jwtService.verify(token); // 验证 JWT
      request.user = payload; // 将用户信息附加到请求对象，供后续使用
      return true;
    } catch (error) {
      throw new UnauthorizedException('Invalid or expired token.');
    }
  }
}
 
// src/articles/articles.controller.ts (使用)
import { Controller, Get, Post, UseGuards } from '@nestjs/common';
import { AuthGuard } from '../common/guards/auth.guard'; // 导入 AuthGuard
 
@Controller('articles')
@UseGuards(AuthGuard) // 应用到整个控制器，所有接口都需要认证
export class ArticlesController {
  @Get()
  findAll() { /* ... */ }
 
  @Post()
  create() { /* ... */ } // 只有认证用户才能创建文章
}

---

3. 拦截器 (Interceptors)

• 类比： 餐厅服务员，可以在上菜前对菜品进行一些处理（如加个装饰），或在厨房做好菜后（但还没上桌前）做一些记录（如记录上菜时间）。
• 执行时机：
  • 在控制器处理函数执行之前（例如，对请求进行预处理）。
  • 在控制器处理函数执行之后，响应发送之前（例如，对响应进行后处理）。
• 作用：
  • 响应转换： 改变控制器方法返回的结果，进行统一的响应格式封装。
  • 异常映射： 将抛出的异常转换为统一的响应格式。
  • 缓存： 在特定条件下缓存响应。
  • 日志记录： 记录请求执行时间、性能监控。
  • 事务处理： 包裹控制器方法，在方法执行前后开启/提交/回滚事务。
• 场景举例 (博客文章管理)：
  • 统一响应格式： 无论控制器返回什么数据，都将其包装成 { code: 200, message: "Success", data: ... } 的统一格式。
  • 性能监控： 记录每个 API 请求从接收到发送响应所花费的时间。
  • 敏感数据过滤： 在响应发送前，从用户对象中移除密码等敏感信息。

// src/common/interceptors/transform.interceptor.ts
import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
import { Observable } from 'rxjs';
import { map } from 'rxjs/operators';
 
export interface Response<T> {
  statusCode: number;
  message: string;
  data: T;
}
 
@Injectable()
export class TransformInterceptor<T> implements NestInterceptor<T, Response<T>> {
  intercept(context: ExecutionContext, next: CallHandler): Observable<Response<T>> {
    return next.handle().pipe(
      map(data => ({
        statusCode: context.switchToHttp().getResponse().statusCode,
        message: 'Success',
        data: data,
      })),
    );
  }
}
 
// src/main.ts 或 src/app.module.ts (全局应用)
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { TransformInterceptor } from './common/interceptors/transform.interceptor';
 
async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.useGlobalInterceptors(new TransformInterceptor()); // 全局应用
  await app.listen(3000);
}
bootstrap();

---

4. 管道 (Pipes)

• 类比： 厨房的食材处理员，他负责对食材进行清洗、切割、检验，确保食材符合烹饪要求。
• 执行时机： 在守卫之后，但在控制器方法执行之前。它作用于路由处理函数的参数。
• 作用：
  • 数据转换 (Transformation)： 将输入数据转换为所需的类型或格式（例如，将字符串 ID 转换为数字）。
  • 数据验证 (Validation)： 确保输入数据符合预期的规则和约束（例如，检查字符串长度、邮箱格式、是否为空）。
• 场景举例 (博客文章管理)：
  • ID 参数转换： 将 URL 中的文章 ID (字符串) 自动转换为数字类型：/articles/:id → id 从 string 变为 number。
  • 请求体验证： 验证创建或更新文章时，title 字段是否为空，content 字段是否达到最小长度。
  • 默认值设置： 如果用户没有提供某个可选参数，则为其设置一个默认值。

// src/articles/dto/create-article.dto.ts (配合 class-validator 和 class-transformer)
import { IsNotEmpty, IsString, MinLength } from 'class-validator';
 
export class CreateArticleDto {
  @IsNotEmpty({ message: '文章标题不能为空' })
  @IsString({ message: '文章标题必须是字符串' })
  title: string;
 
  @IsNotEmpty({ message: '文章内容不能为空' })
  @MinLength(10, { message: '文章内容至少需要10个字符' })
  content: string;
 
  // ... 其他字段
}
 
// src/articles/articles.controller.ts (使用)
import { Controller, Post, Body, Param, ParseIntPipe, UsePipes, ValidationPipe } from '@nestjs/common';
import { CreateArticleDto } from './dto/create-article.dto';
 
@Controller('articles')
export class ArticlesController {
  @Post()
  // ValidationPipe 会自动根据 CreateArticleDto 的装饰器进行验证
  // 如果验证失败，会抛出 BadRequestException
  @UsePipes(new ValidationPipe())
  createArticle(@Body() createArticleDto: CreateArticleDto) {
    console.log('Valid article data:', createArticleDto);
    // ... 业务逻辑
    return { message: 'Article created successfully!' };
  }
 
  @Get(':id')
  // ParseIntPipe 会将 ':id' 参数从字符串转换为数字
  findOne(@Param('id', ParseIntPipe) id: number) {
    console.log('Article ID (number):', id);
    // ... 查找文章
    return { id, title: `Article ${id}` };
  }
}

---

5. 异常过滤器 (Exception Filters)

• 类比： 客服中心，当系统内部发生任何错误时，由它来捕获并给出用户一个友好的、格式统一的错误提示，而不是直接暴露内部错误信息（如堆栈）。
• 执行时机： 当应用内的任何层（守卫、管道、控制器、服务、拦截器）抛出未捕获的异常时。
• 作用： 捕获应用程序中抛出的异常，并以统一的、友好的方式返回给客户端。防止敏感信息泄露，提供更好的用户体验。
• 场景举例 (博客文章管理)：
  • 统一错误响应： 捕获所有 HttpException (如 NotFoundException, BadRequestException) 或自定义异常，并将其转换为 { code: 404, message: "Resource Not Found" } 这样的 JSON 响应。
  • 未知错误处理： 捕获所有未知的、非 HttpException 类型的错误，统一返回 500 Internal Server Error，并记录详细的错误日志。

// src/common/filters/http-exception.filter.ts
import { ExceptionFilter, Catch, ArgumentsHost, HttpException, HttpStatus } 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();
    const errorResponse = exception.getResponse(); // 获取 HttpException 的原始响应体
 
    const errorMessage = typeof errorResponse === 'string'
      ? errorResponse
      : (errorResponse as any).message || 'An unexpected error occurred';
 
    response
      .status(status)
      .json({
        statusCode: status,
        timestamp: new Date().toISOString(),
        path: request.url,
        message: errorMessage,
      });
  }
}
 
// src/main.ts 或 src/app.module.ts (全局应用)
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { HttpExceptionFilter } from './common/filters/http-exception.filter';
 
async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.useGlobalFilters(new HttpExceptionFilter()); // 全局应用
  await app.listen(3000);
}
bootstrap();
 
// 示例：在控制器中抛出异常
// import { Controller, Get, NotFoundException } from '@nestjs/common';
// @Controller('articles')
// export class ArticlesController {
//   @Get(':id')
//   findOne(@Param('id') id: string) {
//     if (id === 'nonexistent') {
//       throw new NotFoundException(`Article with ID ${id} not found.`);
//     }
//     return { id };
//   }
// }

---

总结 NestJS 请求处理的完整流程：

1. 客户端请求
2. 中间件 (Middleware): 执行全局日志记录、API Key 验证等通用请求处理。
3. 守卫 (Guards): 检查用户身份验证状态和操作权限（JWT 验证、角色权限）。
4. 拦截器 (Interceptors - intercept 前半段): 在业务逻辑执行前进行一些预处理，如记录请求开始时间。
5. 管道 (Pipes): 验证请求参数的格式和内容，并进行类型转换 (如 id 字符串转数字)。
6. 控制器/服务 (Controller/Service): 执行核心业务逻辑，调用数据库操作等。
7. (如果业务逻辑成功) 拦截器 (Interceptors - intercept 后半段): 对控制器返回的结果进行统一封装、缓存等操作。
8. (如果业务逻辑抛出异常) 异常过滤器 (Exception Filters): 捕获异常，并统一格式化错误响应。
9. 服务器响应

---

理解这些功能的分层和执行顺序，是掌握 NestJS 强大功能和进行高效开发的基石。它们共同构成了 NestJS 灵活且强大的请求处理管道。您现在可以清晰地看到，每个组件都有其独特的职责和执行时机，避免了职责的混淆，使得代码更加清晰、可维护。

祝您在 NestJS 的后端开发之路上游刃有余！