NestJS核心概念与请求生命周期

后端开发面临的问题：
│
├──  如何组织代码？
│   ├── 路由处理分文件
│   ├── 业务逻辑分文件
│   └── 数据库操作分文件
│
├──  NestJS 的解决方案
│   ├── 提供清晰的核心概念
│   ├── 约定优于配置
│   └── 模块化架构设计
│
└──  核心思想
    └── 让代码逻辑分层更合理，更易理解和维护

┌─────────────────────────────────────────────────────────┐
│                      客户端（Client）                    │
│                   发送 HTTP 请求                         │
└─────────────────────┬───────────────────────────────────┘
                      │
                      ▼
┌─────────────────────────────────────────────────────────┐
│              控制器层（Controller Layer）                │
│  ┌───────────────────────────────────────────────────┐  │
│  │  • 接收请求                                         │  │
│  │  • 解析请求方法（GET/POST/PUT/DELETE）              │  │
│  │  • 分发到对应服务                                   │  │
│  │  • 返回响应                                         │  │
│  └───────────────────────────────────────────────────┘  │
└─────────────────────┬───────────────────────────────────┘
                      │ 调用
                      ▼
┌─────────────────────────────────────────────────────────┐
│               服务层（Service Layer）                    │
│  ┌───────────────────────────────────────────────────┐  │
│  │  • 业务逻辑处理                                     │  │
│  │  • 数据处理和转换                                   │  │
│  │  • 调用数据访问层                                   │  │
│  │  • 返回处理结果                                     │  │
│  └───────────────────────────────────────────────────┘  │
└─────────────────────┬───────────────────────────────────┘
                      │ 查询
                      ▼
┌─────────────────────────────────────────────────────────┐
│         数据访问层（Data Access Layer）                  │
│  ┌───────────────────────────────────────────────────┐  │
│  │  • 数据库模型定义                                   │  │
│  │  • 数据库查询操作                                   │  │
│  │  • 数据持久化                                       │  │
│  │  • ORM/ODM 操作                                     │  │
│  └───────────────────────────────────────────────────┘  │
└─────────────────────┬───────────────────────────────────┘
                      │
                      ▼
                ┌──────────┐
                │ 数据库    │
                │ Database │
                └──────────┘

// src/users/users.controller.ts
import { Controller, Get, Post, Body, Param, Query } from '@nestjs/common';
import { UsersService } from './users.service';
import { CreateUserDto } from './dto/create-user.dto';

@Controller('users')
export class UsersController {
  //  依赖注入：通过构造函数注入 Service
  constructor(private readonly usersService: UsersService) {}

  // GET /users
  @Get()
  findAll() {
    // 调用 Service 处理业务逻辑
    return this.usersService.findAll();
  }

  // GET /users/:id
  @Get(':id')
  findOne(@Param('id') id: string) {
    return this.usersService.findOne(+id);
  }

  // POST /users
  @Post()
  create(@Body() createUserDto: CreateUserDto) {
    return this.usersService.create(createUserDto);
  }

  // PUT /users/:id
  @Put(':id')
  update(@Param('id') id: string, @Body() updateUserDto: UpdateUserDto) {
    return this.usersService.update(+id, updateUserDto);
  }

  // DELETE /users/:id
  @Delete(':id')
  remove(@Param('id') id: string) {
    return this.usersService.remove(+id);
  }
}

Service 层的价值：
│
├──  复用性
│   ├── 接口 A 需要查询用户信息
│   ├── 接口 B 也需要查询用户信息
│   └── 提取成 Service，避免代码重复
│
├──  单一职责
│   ├── Controller 只负责路由分发
│   ├── Service 负责业务逻辑
│   └── 职责清晰，易于维护
│
└──  可测试性
    ├── Service 可独立测试
    ├── Controller 可模拟 Service
    └── 便于单元测试和集成测试

// src/users/users.service.ts
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { User } from './entities/user.entity';
import { CreateUserDto } from './dto/create-user.dto';

@Injectable() //  标记为可注入的 Provider
export class UsersService {
  constructor(
    @InjectRepository(User)
    private userRepository: Repository<User>,
  ) {}

  // 查询所有用户
  async findAll(): Promise<User[]> {
    return this.userRepository.find();
  }

  // 查询单个用户
  async findOne(id: number): Promise<User> {
    return this.userRepository.findOne({ where: { id } });
  }

  // 创建用户
  async create(createUserDto: CreateUserDto): Promise<User> {
    const user = this.userRepository.create(createUserDto);
    return this.userRepository.save(user);
  }

  // 更新用户
  async update(id: number, updateUserDto: UpdateUserDto): Promise<User> {
    await this.userRepository.update(id, updateUserDto);
    return this.findOne(id);
  }

  // 删除用户
  async remove(id: number): Promise<void> {
    await this.userRepository.delete(id);
  }
}

// src/users/entities/user.entity.ts
import { Entity, Column, PrimaryGeneratedColumn } from 'typeorm';

@Entity('users') // 对应数据库表名
export class User {
  @PrimaryGeneratedColumn()
  id: number;

  @Column({ length: 100 })
  name: string;

  @Column({ unique: true })
  email: string;

  @Column()
  age: number;

  @Column({ default: true })
  isActive: boolean;

  @Column({ type: 'timestamp', default: () => 'CURRENT_TIMESTAMP' })
  createdAt: Date;

  @Column({ type: 'timestamp', default: () => 'CURRENT_TIMESTAMP', onUpdate: 'CURRENT_TIMESTAMP' })
  updatedAt: Date;
}

// src/users/users.repository.ts（可选）
import { EntityRepository, Repository } from 'typeorm';
import { User } from './entities/user.entity';

@EntityRepository(User)
export class UsersRepository extends Repository<User> {
  // 自定义查询方法
  async findActiveUsers(): Promise<User[]> {
    return this.createQueryBuilder('user')
      .where('user.isActive = :isActive', { isActive: true })
      .getMany();
  }

  async findByEmail(email: string): Promise<User | undefined> {
    return this.findOne({ where: { email } });
  }
}

依赖关系：

┌──────────────┐
│   Client     │ 发送请求
└──────┬───────┘
       │
       ▼
┌──────────────┐ 依赖
│  Controller  │──────┐
└──────────────┘      │
                      │
                      ▼
                ┌──────────────┐ 依赖
                │   Service    │──────┐
                └──────────────┘      │
                                      │
                                      ▼
                                ┌──────────────┐
                                │  Repository  │
                                └──────┬───────┘
                                       │
                                       ▼
                                 ┌──────────┐
                                 │ Database │
                                 └──────────┘

设计模式：
• 控制器 → 服务：依赖注入（DI）
• 服务 → 仓库：依赖注入（DI）
• 整体架构：面向切面编程（AOP）

NestJS 请求生命周期（非常重要）：

客户端（Client）
    │
    │ 发送请求
    ▼
┌─────────────────────────────────────────────────────────┐
│ 1⃣ 中间件（Middleware）                                  │
│    └─ 全局中间件 → 模块中间件                             │
└─────────────────────┬───────────────────────────────────┘
                      ▼
┌─────────────────────────────────────────────────────────┐
│ 2⃣ 守卫（Guard）                                         │
│    └─ 全局守卫 → 控制器守卫 → 路由守卫                    │
└─────────────────────┬───────────────────────────────────┘
                      ▼
┌─────────────────────────────────────────────────────────┐
│ 3⃣ 拦截器 - 前置（Interceptor Before）                   │
│    └─ 全局拦截器 → 控制器拦截器 → 路由拦截器              │
└─────────────────────┬───────────────────────────────────┘
                      ▼
┌─────────────────────────────────────────────────────────┐
│ 4⃣ 管道（Pipe）                                          │
│    └─ 全局管道 → 控制器管道 → 路由管道 → 参数管道         │
└─────────────────────┬───────────────────────────────────┘
                      ▼
┌─────────────────────────────────────────────────────────┐
│ 5⃣ 控制器方法（Controller Method）                       │
│    └─ 处理请求、调用服务                                  │
└─────────────────────┬───────────────────────────────────┘
                      ▼
┌─────────────────────────────────────────────────────────┐
│ 6⃣ 服务（Service）                                       │
│    └─ 业务逻辑处理、数据库操作                            │
└─────────────────────┬───────────────────────────────────┘
                      ▼
┌─────────────────────────────────────────────────────────┐
│ 7⃣ 拦截器 - 后置（Interceptor After）                    │
│    └─ 路由拦截器 → 控制器拦截器 → 全局拦截器              │
│     注意：与前置拦截器顺序相反                          │
└─────────────────────┬───────────────────────────────────┘
                      ▼
┌─────────────────────────────────────────────────────────┐
│ 8⃣ 异常过滤器（Exception Filter）                        │
│    └─ 路由过滤器 → 控制器过滤器 → 全局过滤器              │
│     仅在异常发生时执行                                  │
└─────────────────────┬───────────────────────────────────┘
                      ▼
                  响应（Response）
                      │
                      ▼
                  客户端（Client）

                    洋葱模型（类似 Koa/Express）

                         ┌─────────────┐
                         │   Client    │
                         └──────┬──────┘
                                │
               ┌────────────────┼────────────────┐
               │                ▼                │
               │         ┌─────────────┐         │
               │         │ Middleware  │         │
               │         └──────┬──────┘         │
               │                │                │
        ┌──────┴──────┐         ▼         ┌──────┴──────┐
        │             │  ┌─────────────┐  │             │
        │             │  │    Guard    │  │             │
        │             │  └──────┬──────┘  │             │
        │             │         │         │             │
   ┌────┴────┐        │         ▼         │        ┌────┴────┐
   │         │        │  ┌─────────────┐  │        │         │
   │         │        │  │ Interceptor │  │        │         │
   │         │        │  │   (Before)  │  │        │         │
   │         │        │  └──────┬──────┘  │        │         │
   │         │        │         │         │        │         │
   │         │   ┌────┴────┐    ▼    ┌────┴────┐   │         │
   │         │   │         │ ┌─────┐ │         │   │         │
   │         │   │         │ │Pipe │ │         │   │         │
   │         │   │         │ └──┬──┘ │         │   │         │
   │         │   │         │    │    │         │   │         │
   │         │   │         │    ▼    │         │   │         │
   │         │   │         │ ┌─────┐ │         │   │         │
   │         │   │         │ │  ↓  │ │         │   │         │
   │         │   │         │ │ Ctrl│ │         │   │         │
   │         │   │         │ │ Svc │ │         │   │         │
   │         │   │         │ │  ↑  │ │         │   │         │
   │         │   │         │ └─────┘ │         │   │         │
   │         │   │         │    │    │         │   │         │
   │         │   │         │    ▼    │         │   │         │
   │         │   │         │ ┌─────┐ │         │   │         │
   │         │   │         │ │Inter│ │         │   │         │
   │         │   │         │ │(Aft)│ │         │   │         │
   │         │   └────┬────┘ └─────┘ └────┬────┘   │         │
   │         │        │         ▲         │        │         │
   │         │        │  ┌─────────────┐  │        │         │
   │         │        │  │   Filter   │  │        │         │
   │         │        │  └─────────────┘  │        │         │
   │         │        │                   │        │         │
   └─────────┴────────┴───────────────────┴────────┴─────────┘
                                │
                                ▼
                          ┌──────────┐
                          │ Response │
                          └──────────┘

关键点：
• 请求从外向内穿透（前置处理）
• 响应从内向外穿透（后置处理）
• 前置和后置拦截器顺序相反

中间件职责：
│
├──  日志记录
│   └── 记录请求信息、响应时间
│
├──  安全处理
│   └── CORS、CSRF、Helmet 等
│
├──  请求预处理
│   └── 解析请求体、添加请求头
│
└──  性能监控
    └── 统计请求处理时间

// 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()}] ${req.method} ${req.url}`);
    
    const start = Date.now();
    
    res.on('finish', () => {
      const duration = Date.now() - start;
      console.log(`请求处理时间: ${duration}ms`);
    });
    
    next();
  }
}

// 在模块中配置
// src/app.module.ts
import { Module, NestModule, MiddlewareConsumer } from '@nestjs/common';
import { LoggerMiddleware } from './common/middleware/logger.middleware';

@Module({})
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer
      .apply(LoggerMiddleware)
      .forRoutes('*'); // 应用到所有路由
  }
}

守卫职责：
│
├──  身份认证
│   └── 验证 Token、Session
│
├──  权限验证
│   └── 检查用户角色、权限
│
├──  访问控制
│   └── 允许或拒绝请求
│
└──  返回布尔值
    ├── true：继续执行
    └── false：抛出 403 异常

// src/common/guards/auth.guard.ts
import { Injectable, CanActivate, ExecutionContext, UnauthorizedException } from '@nestjs/common';

@Injectable()
export class AuthGuard implements CanActivate {
  canActivate(context: ExecutionContext): boolean {
    const request = context.switchToHttp().getRequest();
    const token = request.headers.authorization;

    if (!token) {
      throw new UnauthorizedException('未提供认证令牌');
    }

    // 验证 Token
    const isValid = this.validateToken(token);
    
    if (!isValid) {
      throw new UnauthorizedException('无效的认证令牌');
    }

    return true; // 允许继续执行
  }

  private validateToken(token: string): boolean {
    // 实际项目中应该使用 JWT 验证
    return token === 'valid-token';
  }
}

// 使用示例
@Controller('users')
@UseGuards(AuthGuard) // 控制器级别
export class UsersController {
  
  @Get('admin')
  @UseGuards(AdminGuard) // 路由级别
  getAdminData() {
    return { message: '管理员数据' };
  }
}

前置拦截器职责：
│
├──  请求日志
│   └── 记录请求参数、时间戳
│
├──  请求转换
│   └── 修改请求数据
│
├── ⏱ 性能监控
│   └── 记录开始时间
│
└──  缓存检查
    └── 检查缓存是否存在

// src/common/interceptors/logging.interceptor.ts
import { Injectable, NestInterceptor, ExecutionContext, CallHandler, Logger } from '@nestjs/common';
import { Observable } from 'rxjs';
import { tap } from 'rxjs/operators';

@Injectable()
export class LoggingInterceptor implements NestInterceptor {
  private readonly logger = new Logger(LoggingInterceptor.name);

  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    const request = context.switchToHttp().getRequest();
    const { method, url, body } = request;
    const now = Date.now();

    // 前置处理：记录请求信息
    this.logger.log(`\n
      ========== 请求开始 ==========
      方法: ${method}
      路径: ${url}
      请求体: ${JSON.stringify(body)}
      时间: ${new Date().toISOString()}
      ==============================
    `);

    return next.handle().pipe(
      tap((data) => {
        // 后置处理：记录响应信息
        const duration = Date.now() - now;
        this.logger.log(`\n
          ========== 响应完成 ==========
          路径: ${url}
          耗时: ${duration}ms
          ==============================
        `);
      }),
    );
  }
}

管道职责：
│
├──  参数验证
│   └── 验证请求参数格式、类型
│
├──  数据转换
│   └── 字符串转数字、日期转换
│
├──  数据清洗
│   └── 去除空格、过滤字段
│
└──  验证失败
    └── 抛出 400 Bad Request

// src/common/pipes/validation.pipe.ts
import { PipeTransform, Injectable, ArgumentMetadata, BadRequestException } from '@nestjs/common';
import { validate } from 'class-validator';
import { plainToInstance } from 'class-transformer';

@Injectable()
export class ValidationPipe implements PipeTransform<any> {
  async transform(value: any, { metatype }: ArgumentMetadata) {
    if (!metatype || !this.toValidate(metatype)) {
      return value;
    }

    const object = plainToInstance(metatype, value);
    const errors = await validate(object);

    if (errors.length > 0) {
      const messages = errors.map(error => ({
        property: error.property,
        constraints: error.constraints,
      }));

      throw new BadRequestException({
        code: 400,
        message: '参数验证失败',
        errors: messages,
      });
    }

    return value;
  }

  private toValidate(metatype: Function): boolean {
    const types: Function[] = [String, Boolean, Number, Array, Object];
    return !types.includes(metatype);
  }
}

// 使用示例
@Post()
create(@Body() createUserDto: CreateUserDto) {
  // 参数已自动验证
  return this.usersService.create(createUserDto);
}

控制器方法职责：
│
├──  接收验证后的参数
│
├──  调用服务方法
│
├──  返回处理结果
│
└──  路由分发

@Controller('users')
export class UsersController {
  constructor(private readonly usersService: UsersService) {}

  @Post()
  create(@Body() createUserDto: CreateUserDto) {
    // 参数已通过管道验证
    // 调用 Service 处理业务逻辑
    return this.usersService.create(createUserDto);
  }
}

服务职责：
│
├──  业务逻辑处理
│
├──  数据计算和转换
│
├──  数据库操作
│
├──  调用其他服务
│
└──  返回处理结果

@Injectable()
export class UsersService {
  async create(createUserDto: CreateUserDto): Promise<User> {
    // 1. 业务逻辑处理
    const hashedPassword = await this.hashPassword(createUserDto.password);
    
    // 2. 数据库操作
    const user = this.userRepository.create({
      ...createUserDto,
      password: hashedPassword,
    });
    
    // 3. 保存数据
    await this.userRepository.save(user);
    
    // 4. 返回结果
    return user;
  }
}

后置拦截器职责：
│
├──  响应日志
│   └── 记录响应数据
│
├──  响应转换
│   └── 统一响应格式
│
├──  缓存保存
│   └── 将结果缓存
│
└── ⏱ 性能统计
    └── 计算总耗时

// 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> {
  code: number;
  data: T;
  message: string;
  timestamp: string;
}

@Injectable()
export class TransformInterceptor<T> implements NestInterceptor<T, Response<T>> {
  intercept(context: ExecutionContext, next: CallHandler): Observable<Response<T>> {
    return next.handle().pipe(
      map(data => ({
        code: 0,
        data,
        message: '请求成功',
        timestamp: new Date().toISOString(),
      })),
    );
  }
}

// 响应格式
{
  "code": 0,
  "data": { "id": 1, "name": "张三" },
  "message": "请求成功",
  "timestamp": "2026-03-07T10:30:00.000Z"
}

异常过滤器职责：
│
├──  捕获异常
│   └── 捕获未处理的异常
│
├──  记录错误日志
│   └── 记录异常堆栈信息
│
├──  格式化错误响应
│   └── 统一错误返回格式
│
└──  错误监控
    └── 发送错误通知

// src/common/filters/http-exception.filter.ts
import {
  ExceptionFilter,
  Catch,
  ArgumentsHost,
  HttpException,
  HttpStatus,
  Logger,
} from '@nestjs/common';
import { Request, Response } from 'express';

@Catch()
export class HttpExceptionFilter implements ExceptionFilter {
  private readonly logger = new Logger(HttpExceptionFilter.name);

  catch(exception: unknown, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse<Response>();
    const request = ctx.getRequest<Request>();

    let status = HttpStatus.INTERNAL_SERVER_ERROR;
    let message = '服务器内部错误';
    let error = 'Internal Server Error';

    if (exception instanceof HttpException) {
      status = exception.getStatus();
      const exceptionResponse = exception.getResponse();
      
      if (typeof exceptionResponse === 'object') {
        message = (exceptionResponse as any).message || message;
        error = (exceptionResponse as any).error || error;
      }
    }

    // 记录错误日志
    this.logger.error(`\n
      ========== 异常信息 ==========
      路径: ${request.url}
      方法: ${request.method}
      状态码: ${status}
      错误: ${error}
      消息: ${message}
      ==============================
    `);

    // 统一返回格式
    response.status(status).json({
      code: status,
      data: null,
      message: message,
      error: error,
      timestamp: new Date().toISOString(),
      path: request.url,
    });
  }
}

// ========== 1. 中间件 ==========

@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: NextFunction) {
    console.log('1⃣ 中间件：记录请求日志');
    next();
  }
}

// ========== 2. 守卫 ==========

@Injectable()
export class AuthGuard implements CanActivate {
  canActivate(context: ExecutionContext): boolean {
    console.log('2⃣ 守卫：验证用户身份');
    return true;
  }
}

// ========== 3. 拦截器（前置）==========

@Injectable()
export class LoggingInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    console.log('3⃣ 拦截器（前置）：请求开始');
    
    return next.handle().pipe(
      tap(() => {
        console.log('7⃣ 拦截器（后置）：响应完成');
      }),
    );
  }
}

// ========== 4. 管道 ==========

@Injectable()
export class ValidationPipe implements PipeTransform {
  transform(value: any, metadata: ArgumentMetadata) {
    console.log('4⃣ 管道：参数验证');
    return value;
  }
}

// ========== 5. 控制器 ==========

@Controller('users')
@UseGuards(AuthGuard)
@UseInterceptors(LoggingInterceptor)
@UsePipes(ValidationPipe)
export class UsersController {
  constructor(private readonly usersService: UsersService) {}

  @Post()
  create(@Body() createUserDto: CreateUserDto) {
    console.log('5⃣ 控制器：处理请求');
    return this.usersService.create(createUserDto);
  }
}

// ========== 6. 服务 ==========

@Injectable()
export class UsersService {
  async create(createUserDto: CreateUserDto) {
    console.log('6⃣ 服务：业务逻辑处理');
    return { id: 1, ...createUserDto };
  }
}

// ========== 8. 异常过滤器 ==========

@Catch()
export class HttpExceptionFilter implements ExceptionFilter {
  catch(exception: unknown, host: ArgumentsHost) {
    console.log('8⃣ 异常过滤器：捕获异常');
    // 处理异常
  }
}

// ========== 执行顺序 ==========

// 控制台输出：
// 1⃣ 中间件：记录请求日志
// 2⃣ 守卫：验证用户身份
// 3⃣ 拦截器（前置）：请求开始
// 4⃣ 管道：参数验证
// 5⃣ 控制器：处理请求
// 6⃣ 服务：业务逻辑处理
// 7⃣ 拦截器（后置）：响应完成

前端 vs 后端生命周期理解：

前端生命周期：
│
├── 创建阶段
│   └── beforeCreate、created
│
├── 挂载阶段
│   └── beforeMount、mounted
│
├── 更新阶段
│   └── beforeUpdate、updated
│
└── 销毁阶段
    └── beforeDestroy、destroyed

后端生命周期：
│
├── 请求阶段（前置）
│   └── 中间件 → 守卫 → 拦截器 → 管道
│
├── 处理阶段
│   └── 控制器 → 服务
│
└── 响应阶段（后置）
    └── 拦截器 → 过滤器 → 响应

共同点：
• 都是钩子方法
• 都在特定时机执行
• 都可以插入自定义逻辑

生命周期简化记忆：

请求流程：客户端 → 中间件 → 守卫 → 拦截器 → 管道 → 控制器 → 服务

响应流程：服务 → 拦截器（反向）→ 过滤器 → 客户端

关键点：
1⃣ 中间件最先执行
2⃣ 守卫验证权限
3⃣ 拦截器前后都有（洋葱模型）
4⃣ 管道验证参数
5⃣ 控制器处理请求
6⃣ 服务处理业务
7⃣ 过滤器处理异常

学习建议：
│
├──  理解每个组件的作用
│   └── 中间件干啥？守卫干啥？
│
├──  知道大致顺序
│   └── 前置 → 处理 → 后置
│
├──  需要时查阅文档
│   └── 这张图不需要背
│
└──  用过一次就记住了
    └── 实践是最好的老师

//  避免：在守卫中执行耗时操作
@Injectable()
export class BadGuard implements CanActivate {
  async canActivate(context: ExecutionContext): boolean {
    // 不要在守卫中执行数据库查询
    await this.userService.findAll(); // 性能杀手
    return true;
  }
}

//  推荐：守卫只做轻量级验证
@Injectable()
export class GoodGuard implements CanActivate {
  canActivate(context: ExecutionContext): boolean {
    const request = context.switchToHttp().getRequest();
    const token = request.headers.authorization;
    return !!token; // 简单验证
  }
}

学习路径：
│
├──  第一阶段：理解概念（1-2 天）
│   ├── 理解三大核心概念
│   ├── 理解生命周期流程
│   └── 理解各组件职责
│
├──  第二阶段：实践练习（1 周）
│   ├── 实现中间件日志
│   ├── 实现守卫认证
│   ├── 实现拦截器转换
│   └── 实现管道验证
│
└──  第三阶段：深入应用（持续）
    ├── 理解组件执行顺序
    ├── 性能优化
    └── 最佳实践

思考题：
│
├──  为什么要将业务逻辑放在 Service 而不是 Controller？
├──  拦截器的前置和后置为什么要相反？
├──  如何优化生命周期的性能？
├──  在什么场景下使用哪个组件？
└──  如何设计一个合理的架构？