NestJS框架对比与架构优势

Node.js Web 框架演进史：
│
├── 2009 - Express
│   └── 第一个流行的 Node.js Web 框架
│
├── 2013 - Koa
│   └── Express 原班人马打造，更轻量、现代化
│
├── 2016 - Egg.js
│   └── 阿里出品，企业级框架，基于 Koa
│
└── 2017 - NestJS
    └── Angular 风格，TypeScript 优先，企业级架构

Express 特点：
│
├──  优势
│   ├── 生态最丰富，中间件众多
│   ├── 文档完善，社区活跃
│   ├── 灵活自由，无强制架构
│   └── 学习成本低，上手快
│
└──  劣势
    ├── 无 TypeScript 原生支持
    ├── 回调地狱（老版本）
    ├── 缺乏架构指导
    └── 大型项目难以维护

// ===== Express 基础示例 =====
const express = require('express');
const app = express();

// 中间件：解析 JSON
app.use(express.json());

// 路由定义
app.get('/', (req, res) => {
  res.send('Hello World');
});

app.get('/users', (req, res) => {
  res.json([
    { id: 1, name: '张三' },
    { id: 2, name: '李四' }
  ]);
});

app.post('/users', (req, res) => {
  const { name, email } = req.body;
  // 业务逻辑混在路由中
  const newUser = { id: Date.now(), name, email };
  res.status(201).json(newUser);
});

// 启动服务
app.listen(3000, () => {
  console.log('Server running on http://localhost:3000');
});

//  问题：
// 1. 缺乏分层，业务逻辑与路由耦合
// 2. 无依赖注入，需手动管理依赖
// 3. 无类型检查，容易出错

Koa 特点：
│
├──  优势
│   ├── 更轻量，核心仅 550 行代码
│   ├── async/await 支持，代码更优雅
│   ├── 洋葱模型中间件，控制流清晰
│   └── 无捆绑中间件，自由选择
│
└──  劣势
    ├── 功能太少，需自己实现路由等
    ├── 生态不如 Express 丰富
    ├── 无架构指导
    └── TypeScript 支持需配置

// ===== Koa 基础示例 =====
const Koa = require('koa');
const Router = require('koa-router');
const bodyParser = require('koa-bodyparser');

const app = new Koa();
const router = new Router();

// 中间件：洋葱模型示例
app.use(async (ctx, next) => {
  console.log('第一层中间件 - 开始');
  await next();
  console.log('第一层中间件 - 结束');
});

app.use(async (ctx, next) => {
  console.log('第二层中间件 - 开始');
  await next();
  console.log('第二层中间件 - 结束');
});

// 解析请求体
app.use(bodyParser());

// 路由定义
router.get('/', async (ctx) => {
  ctx.body = 'Hello World';
});

router.get('/users', async (ctx) => {
  ctx.body = [
    { id: 1, name: '张三' },
    { id: 2, name: '李四' }
  ];
});

router.post('/users', async (ctx) => {
  const { name, email } = ctx.request.body;
  const newUser = { id: Date.now(), name, email };
  ctx.status = 201;
  ctx.body = newUser;
});

// 注册路由
app.use(router.routes()).use(router.allowedMethods());

// 启动服务
app.listen(3000, () => {
  console.log('Server running on http://localhost:3000');
});

//  优点：洋葱模型清晰，async/await 优雅
//  问题：需自己搭建架构，缺乏分层

请求 → 中间件1 → 中间件2 → 中间件3 → 路由处理
                                              ↓
响应 ← 中间件1 ← 中间件2 ← 中间件3 ← 业务逻辑

执行顺序：
1. 请求进入中间件1
2. 调用 next() 进入中间件2
3. 调用 next() 进入中间件3
4. 调用 next() 进入路由处理
5. 路由处理完成，返回中间件3
6. 中间件3 完成，返回中间件2
7. 中间件2 完成，返回中间件1
8. 中间件1 完成，响应客户端

Egg.js 特点：
│
├──  优势
│   ├── 企业级架构，开箱即用
│   ├── 约定优于配置，规范统一
│   ├── 插件机制丰富
│   ├── 中文文档完善（阿里团队）
│   └── 内置安全、日志等功能
│
└──  劣势
    ├── TypeScript 支持不佳（需 Babel 编译）
    ├── 基于 CommonJS 规范，现代化不足
    ├── 学习成本较高（约定多）
    └── 性能略有损耗（封装层多）

// ===== Egg.js 项目结构 =====
egg-project/
├── app/
│   ├── controller/          # 控制器
│   │   └── home.js
│   ├── service/             # 服务层
│   │   └── user.js
│   ├── middleware/          # 中间件
│   ├── router.js            # 路由配置
│   └── extend/              # 扩展
├── config/
│   ├── config.default.js    # 配置文件
│   └── plugin.js            # 插件配置
└── package.json

// ===== app/router.js - 路由配置 =====
module.exports = app => {
  const { router, controller } = app;
  router.get('/', controller.home.index);
  router.get('/users', controller.user.list);
  router.post('/users', controller.user.create);
};

// ===== app/controller/home.js - 控制器 =====
const Controller = require('egg').Controller;

class HomeController extends Controller {
  async index() {
    const { ctx } = this;
    ctx.body = 'Hello World';
  }
}

module.exports = HomeController;

// ===== app/controller/user.js - 用户控制器 =====
const Controller = require('egg').Controller;

class UserController extends Controller {
  async list() {
    const { ctx, service } = this;
    const users = await service.user.getList();
    ctx.body = users;
  }

  async create() {
    const { ctx, service } = this;
    const { name, email } = ctx.request.body;
    const user = await service.user.create({ name, email });
    ctx.status = 201;
    ctx.body = user;
  }
}

module.exports = UserController;

// ===== app/service/user.js - 服务层 =====
const Service = require('egg').Service;

class UserService extends Service {
  async getList() {
    // 模拟数据库查询
    return [
      { id: 1, name: '张三', email: 'zhangsan@example.com' },
      { id: 2, name: '李四', email: 'lisi@example.com' }
    ];
  }

  async create(data) {
    // 模拟创建用户
    return { id: Date.now(), ...data };
  }
}

module.exports = UserService;

//  优点：分层清晰（Controller/Service）、规范统一
//  问题：TypeScript 支持不佳、基于 CommonJS 规范

NestJS 核心优势：
│
├──  架构设计
│   ├── Angular 风格，前端开发者友好
│   ├── Spring 设计思想，后端架构完善
│   ├── 强制模块化，代码组织清晰
│   └── 依赖注入（DI），解耦彻底
│
├──  TypeScript 原生支持
│   ├── 类型安全，减少运行时错误
│   ├── 装饰器语法，代码简洁优雅
│   ├── IDE 友好，智能提示完善
│   └── 重构容易，维护成本低
│
├──  企业级特性
│   ├── 模块（Module）系统
│   ├── 控制器（Controller）路由
│   ├── 服务（Service）业务逻辑
│   ├── 管道（Pipe）数据验证
│   ├── 守卫（Guard）权限控制
│   ├── 拦截器（Interceptor）AOP
│   └── 过滤器（Filter）异常处理
│
├──  底层灵活
│   ├── 默认使用 Express
│   ├── 可替换为 Fastify（高性能）
│   └── 支持微服务、WebSocket、GraphQL
│
└──  生态与文档
    ├── 官方文档非常完善
    ├── 社区活跃，更新频繁
    ├── 官方模块丰富
    └── 企业级解决方案多

NestJS 架构灵感来源：
│
├── Angular（前端框架）
│   ├── 模块化设计
│   ├── 依赖注入系统
│   ├── 装饰器语法
│   └── 元编程思想
│
└── Spring（Java 后端框架）
    ├── IoC 容器
    ├── AOP 编程
    ├── 分层架构
    └── 企业级最佳实践

架构层次对比：
│
├── Express / Koa
│   └── 仅实现 HTTP 服务
│       └── 需自己搭建：路由、日志、验证、分层
│
├── Egg.js
│   ├── 封装了 Koa
│   ├── 提供了 MVC 分层
│   ├── 但缺乏 TypeScript 支持
│   └── 架构灵活性不足
│
└── NestJS
    ├── 完整的架构体系
    ├── TypeScript 原生支持
    ├── DI + AOP + 装饰器
    ├── 底层可替换（Express/Fastify）
    └── 开箱即用的企业级特性

// ===== Express 实现 =====
const express = require('express');
const app = express();

app.use(express.json());

//  问题：路由、验证、业务逻辑混在一起
app.get('/users', (req, res) => {
  // 数据库查询逻辑
  const users = [{ id: 1, name: '张三' }];
  res.json(users);
});

app.post('/users', (req, res) => {
  const { name, email } = req.body;
  
  //  验证逻辑混在控制器中
  if (!name || !email) {
    return res.status(400).json({ error: '参数错误' });
  }
  
  //  业务逻辑混在控制器中
  const newUser = { id: Date.now(), name, email };
  res.status(201).json(newUser);
});

app.listen(3000);

// 问题总结：
// 1. 无分层架构
// 2. 无依赖注入
// 3. 无类型检查
// 4. 代码耦合严重

// ===== Koa 实现 =====
const Koa = require('koa');
const Router = require('koa-router');
const bodyParser = require('koa-bodyparser');

const app = new Koa();
const router = new Router();

app.use(bodyParser());

//  问题：比 Express 更优雅，但仍然缺乏架构
router.get('/users', async (ctx) => {
  const users = [{ id: 1, name: '张三' }];
  ctx.body = users;
});

router.post('/users', async (ctx) => {
  const { name, email } = ctx.request.body;
  
  //  验证逻辑手动实现
  if (!name || !email) {
    ctx.status = 400;
    ctx.body = { error: '参数错误' };
    return;
  }
  
  const newUser = { id: Date.now(), name, email };
  ctx.status = 201;
  ctx.body = newUser;
});

app.use(router.routes());
app.listen(3000);

// 优点：async/await 优雅
// 问题：架构需自己搭建

// ===== Egg.js 实现 =====

// app/router.js
module.exports = app => {
  const { router, controller } = app;
  router.get('/users', controller.user.list);
  router.post('/users', controller.user.create);
};

// app/controller/user.js
const Controller = require('egg').Controller;

class UserController extends Controller {
  async list() {
    const { ctx, service } = this;
    const users = await service.user.getList();
    ctx.body = users;
  }

  async create() {
    const { ctx, service } = this;
    const { name, email } = ctx.request.body;
    
    //  验证需手动实现或使用插件
    if (!name || !email) {
      ctx.status = 400;
      ctx.body = { error: '参数错误' };
      return;
    }
    
    const user = await service.user.create({ name, email });
    ctx.status = 201;
    ctx.body = user;
  }
}

module.exports = UserController;

// app/service/user.js
const Service = require('egg').Service;

class UserService extends Service {
  async getList() {
    return [{ id: 1, name: '张三' }];
  }

  async create(data) {
    return { id: Date.now(), ...data };
  }
}

module.exports = UserService;

// 优点：分层清晰（Controller/Service）
// 问题：TypeScript 支持不佳

// ===== NestJS 实现 =====

// src/main.ts - 入口文件
import { NestFactory } from '@nestjs/core';
import { ValidationPipe } from '@nestjs/common';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  
  // 全局验证管道
  app.useGlobalPipes(new ValidationPipe({
    whitelist: true,
    forbidNonWhitelisted: true,
    transform: true,
  }));
  
  await app.listen(3000);
}
bootstrap();

// src/app.module.ts - 根模块
import { Module } from '@nestjs/common';
import { UsersModule } from './users/users.module';

@Module({
  imports: [UsersModule],
})
export class AppModule {}

// src/users/users.module.ts - 用户模块
import { Module } from '@nestjs/common';
import { UsersController } from './users.controller';
import { UsersService } from './users.service';

@Module({
  controllers: [UsersController],
  providers: [UsersService],
})
export class UsersModule {}

// src/users/dto/create-user.dto.ts - 数据传输对象
import { IsString, IsEmail, IsInt, Min, Max, IsNotEmpty } from 'class-validator';

export class CreateUserDto {
  @IsString({ message: 'name 必须是字符串' })
  @IsNotEmpty({ message: 'name 不能为空' })
  name: string;

  @IsEmail({}, { message: 'email 格式不正确' })
  @IsNotEmpty({ message: 'email 不能为空' })
  email: string;

  @IsInt({ message: 'age 必须是整数' })
  @Min(0, { message: 'age 不能小于 0' })
  @Max(150, { message: 'age 不能大于 150' })
  age?: number;
}

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

@Controller('users')
export class UsersController {
  //  依赖注入：自动注入 UsersService
  constructor(private readonly usersService: UsersService) {}

  @Get()
  findAll(): Promise<User[]> {
    return this.usersService.findAll();
  }

  @Get(':id')
  findOne(@Param('id', ParseIntPipe) id: number): Promise<User> {
    return this.usersService.findOne(id);
  }

  @Post()
  create(@Body() createUserDto: CreateUserDto): Promise<User> {
    //  自动验证：ValidationPipe 会自动验证 DTO
    return this.usersService.create(createUserDto);
  }
}

// src/users/users.service.ts - 服务
import { Injectable, NotFoundException } from '@nestjs/common';
import { CreateUserDto } from './dto/create-user.dto';

export interface User {
  id: number;
  name: string;
  email: string;
  age?: number;
}

@Injectable()
export class UsersService {
  private users: User[] = [
    { id: 1, name: '张三', email: 'zhangsan@example.com', age: 25 },
  ];

  findAll(): User[] {
    return this.users;
  }

  findOne(id: number): User {
    const user = this.users.find(u => u.id === id);
    if (!user) {
      throw new NotFoundException(`User with id ${id} not found`);
    }
    return user;
  }

  create(createUserDto: CreateUserDto): User {
    const newUser: User = {
      id: Date.now(),
      ...createUserDto,
    };
    this.users.push(newUser);
    return newUser;
  }
}

// ===== 优势总结 =====
//  1. 类型安全：TypeScript 完整类型检查
//  2. 自动验证：ValidationPipe + class-validator
//  3. 依赖注入：自动管理依赖关系
//  4. 分层清晰：Controller/Service/DTO 分离
//  5. 装饰器语法：代码简洁优雅
//  6. 异常处理：统一异常过滤器
//  7. 管道转换：ParseIntPipe 自动转换参数类型

// ===== 依赖注入原理 =====

//  传统方式：手动创建依赖
class UserController {
  private userService: UserService;
  
  constructor() {
    // 手动实例化，紧耦合
    this.userService = new UserService();
  }
}

//  NestJS 方式：依赖注入
@Controller('users')
export class UsersController {
  // 自动注入，松耦合
  constructor(private readonly usersService: UsersService) {}
  
  @Get()
  findAll() {
    return this.usersService.findAll();
  }
}

// ===== 依赖注入的优势 =====
// 1. 松耦合：Controller 不依赖具体的 Service 实现
// 2. 易测试：可以轻松 mock Service 进行单元测试
// 3. 易维护：修改 Service 实现不影响 Controller
// 4. 易扩展：可以轻松替换实现（如切换数据库）

// ===== 高级用法：自定义 Provider =====
@Module({
  providers: [
    // 方式1：标准写法
    {
      provide: 'USER_SERVICE',
      useClass: UsersService,
    },
    
    // 方式2：使用值
    {
      provide: 'CONFIG',
      useValue: { db: 'mysql', port: 3000 },
    },
    
    // 方式3：使用工厂函数
    {
      provide: 'CONNECTION',
      useFactory: (configService: ConfigService) => {
        return createConnection(configService.dbConfig);
      },
      inject: [ConfigService],
    },
  ],
})
export class AppModule {}

// 使用自定义 Provider
@Controller('users')
export class UsersController {
  constructor(
    @Inject('USER_SERVICE') private usersService: UsersService,
    @Inject('CONFIG') private config: any,
  ) {}
}

// ===== 内置管道 =====
import { 
  PipeTransform, 
  Injectable, 
  ArgumentMetadata,
  ParseIntPipe,
  ValidationPipe,
} from '@nestjs/common';

// 1. ParseIntPipe - 参数类型转换
@Get(':id')
findOne(@Param('id', ParseIntPipe) id: number) {
  // id 自动转换为 number 类型
  return this.usersService.findOne(id);
}

// 2. ValidationPipe - 数据验证
// 全局启用
app.useGlobalPipes(new ValidationPipe());

// ===== 自定义管道 =====
@Injectable()
export class ValidationPipe implements PipeTransform {
  transform(value: any, metadata: ArgumentMetadata) {
    // 验证逻辑
    if (!value) {
      throw new BadRequestException('Validation failed');
    }
    return value;
  }
}

// ===== 使用 class-validator 进行验证 =====
// 安装：pnpm add class-validator class-transformer

import { IsString, IsEmail, IsInt, Min, Max } from 'class-validator';

export class CreateUserDto {
  @IsString()
  name: string;

  @IsEmail()
  email: string;

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

// Controller 中使用
@Post()
create(@Body() createUserDto: CreateUserDto) {
  // ValidationPipe 会自动验证
  return this.usersService.create(createUserDto);
}

// ===== 守卫示例：JWT 认证 =====
import { 
  Injectable, 
  CanActivate, 
  ExecutionContext,
  UnauthorizedException,
} from '@nestjs/common';
import { JwtService } from '@nestjs/jwt';

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

  canActivate(context: ExecutionContext): boolean {
    const request = context.switchToHttp().getRequest();
    const token = request.headers.authorization?.split(' ')[1];
    
    if (!token) {
      throw new UnauthorizedException('未登录');
    }
    
    try {
      const payload = this.jwtService.verify(token);
      request.user = payload;
      return true;
    } catch (error) {
      throw new UnauthorizedException('token 无效');
    }
  }
}

// 使用守卫
@Controller('users')
@UseGuards(AuthGuard)  // 整个控制器启用
export class UsersController {
  
  @Get('profile')
  getProfile(@Request() req) {
    return req.user;  // 守卫中注入的用户信息
  }
}

// ===== 拦截器示例：日志记录 =====
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 } = request;
    const now = Date.now();

    return next
      .handle()
      .pipe(
        tap(() => {
          this.logger.log(
            `${method} ${url} - ${Date.now() - now}ms`
          );
        }),
      );
  }
}

// 使用拦截器
@Controller('users')
@UseInterceptors(LoggingInterceptor)
export class UsersController {
  // 所有请求都会记录日志
}

// 默认使用 Express
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
}
bootstrap();

// 切换为 Fastify
import { NestFactory } from '@nestjs/core';
import {
  FastifyAdapter,
  NestFastifyApplication,
} from '@nestjs/platform-fastify';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create<NestFastifyApplication>(
    AppModule,
    new FastifyAdapter(),
  );
  await app.listen(3000);
}
bootstrap();

// Fastify 性能对比：
// - Express：~10k req/s
// - Fastify：~30k req/s
// 性能提升：3倍左右

NestJS 底层架构：
│
├── HTTP 适配器层（可替换）
│   ├── ExpressAdapter（默认）
│   │   ├── 生态丰富
│   │   ├── 文档完善
│   │   └── 性能良好
│   │
│   └── FastifyAdapter（高性能）
│       ├── 性能卓越（3倍 Express）
│       ├── 生态略小
│       └── 官方推荐生产环境
│
└── NestJS 核心层（不变）
    ├── 模块系统
    ├── 依赖注入
    ├── 管道/守卫/拦截器
    └── 所有功能不受影响

项目选型决策：
│
├── 小型项目 / 个人项目
│   ├── 快速原型 → Express
│   ├── 学习入门 → Express / Koa
│   └── 高性能需求 → Koa + Fastify
│
├── 中型项目 / 团队项目
│   ├── 国内团队 → Egg.js
│   ├── TypeScript 技术栈 → NestJS
│   └── 快速开发 → Egg.js / NestJS
│
└── 大型项目 / 企业项目
    ├── 微服务架构 → NestJS
    ├── GraphQL API → NestJS
    ├── 长期维护 → NestJS
    └── 团队规范统一 → NestJS

NestJS 最佳实践场景：
│
├──  企业级应用
│   ├── 中大型项目
│   ├── 长期维护项目
│   └── 团队协作项目
│
├──  特定架构需求
│   ├── 微服务架构
│   ├── GraphQL API
│   ├── WebSocket 应用
│   └── RESTful API
│
├──  团队背景
│   ├── 前端团队为主
│   ├── Angular 技术栈
│   ├── TypeScript 技术栈
│   └── 全栈开发团队
│
└──  业务特点
    ├── 业务逻辑复杂
    ├── 需要良好的架构设计
    ├── 需要完善的权限控制
    └── 需要统一代码规范

学习路径建议：
│
├──  阶段一：Express/Koa 基础（1 周）
│   ├── 理解中间件机制
│   ├── 掌握路由设计
│   └── 了解 Web 框架原理
│
├──  阶段二：TypeScript 进阶（1 周）
│   ├── 装饰器语法
│   ├── 泛型编程
│   └── 元数据反射
│
├──  阶段三：NestJS 核心（2-3 周）
│   ├── 模块系统
│   ├── 依赖注入
│   ├── 管道/守卫/拦截器
│   └── 数据库集成
│
└──  阶段四：实战项目（3-4 周）
    ├── RESTful API 开发
    ├── 用户认证授权
    ├── 微服务架构
    └── 性能优化

// ===== Express =====
app.get('/users', (req, res) => { res.json(users); });

// ===== Koa =====
router.get('/users', async (ctx) => { ctx.body = users; });

// ===== Egg.js =====
router.get('/users', controller.user.list);

// ===== NestJS =====
@Controller('users')
export class UsersController {
  @Get() findAll() { return this.usersService.findAll(); }
}

// ===== Express =====
app.use((req, res, next) => { next(); });

// ===== Koa =====
app.use(async (ctx, next) => { await next(); });

// ===== NestJS =====
@Injectable()
export class LoggingMiddleware implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler) {
    return next.handle();
  }
}