【NestJS】18 项目架构全景图：从零散知识到完整体系

1
1. 创建应用实例（NestFactory.create）
2
   ↓
3
2. 配置全局功能
4
   - ValidationPipe：验证所有输入数据
5
   - CORS：允许跨域请求
6
   - 全局拦截器：统一响应格式
7
   - 全局过滤器：统一错误处理
8
   ↓
9
3. 启动服务器（listen(3000)）

1
ConfigModule      → 管理环境变量（API Key、数据库地址）
2
MongooseModule    → 连接数据库
3
JwtModule         → 配置 JWT 认证
4
PassportModule    → 配置认证策略

1
UserModule        → 用户管理
2
InterviewModule   → 面试功能
3
PaymentModule     → 支付功能
4
ResumeModule      → 简历管理
5
...

1
ResponseInterceptor     → 统一响应格式
2
AllExceptionsFilter     → 统一错误处理

1
@Module({
2
  imports: [...]      // 我需要用到的其他模块
3
  providers: [...]    // 我提供的服务（Service）
4
  controllers: [...]  // 我提供的接口（Controller）
5
  exports: [...]      // 我允许别人用的服务
6
})

1
1. 请求进入应用（main.ts）
2
   ↓
3
2. ValidationPipe 验证数据
4
   - 检查参数格式是否正确
5
   - 不符合？直接拒绝，返回 400 错误
6
   ↓
7
3. JwtAuthGuard 验证身份
8
   - 检查 Token 是否有效
9
   - 无效？返回 401 错误（未认证）
10
   ↓
11
4. RolesGuard 验证权限
12
   - 检查用户是否有权限
13
   - 没权限？返回 403 错误（禁止访问）
14
   ↓
15
5. 到达 Controller
16
   - 找到对应的方法
17
   - 提取参数
18
   ↓
19
6. Controller 调用 Service
20
   - Service 处理业务逻辑
21
   - 可能调用其他 Service
22
   - 可能查询数据库
23
   ↓
24
7. 返回数据
25
   ↓
26
8. ResponseInterceptor 格式化响应
27
   - 统一包装成 { code, message, data }
28
   ↓
29
9. 返回给客户端

1
任何一步出错
2
   ↓
3
抛出异常
4
   ↓
5
AllExceptionsFilter 捕获
6
   ↓
7
格式化成统一的错误响应
8
   ↓
9
返回给客户端

1
UserModule
2
├── User Schema        → 用户数据结构
3
├── UserService        → 用户业务逻辑
4
├── UserController     → 用户接口
5
└── exports: [UserService]  → 导出给其他模块用

1
InterviewModule 需要：
2
├── 访问用户数据        → 导入 UserModule
3
├── 访问简历数据        → 导入 ResumeModule
4
├── 调用 AI 服务        → 使用 InterviewAIService
5
├── 解析文档           → 使用 DocumentParserService
6
├── 访问配置           → 导入 ConfigModule
7
└── 访问多个数据表      → 导入多个 Schema

1
AppModule（根模块）
2
    ↓
3
    ├── UserModule（核心）
4
    │   └── 导出 UserService
5
    │
6
    ├── InterviewModule（中心）
7
    │   ├── 导入 UserModule
8
    │   ├── 导入 ResumeModule
9
    │   └── 导入 ConfigModule
10
    │
11
    ├── PaymentModule
12
    │   └── 导入 UserModule
13
    │
14
    ├── ResumeModule
15
    │   └── 导入 UserModule
16
    │
17
    └── WechatModule
18
        └── 导入 UserModule

1
不分模块：
2
所有代码在一起 → 找不到 → 改不动
3

4
分模块：
5
用户相关在 UserModule → 一眼就找到

1
不分模块：
2
改一个功能，影响其他功能 → 容易出 bug
3

4
分模块：
5
改 UserModule，不影响 InterviewModule

1
不分模块：
2
加新功能，不知道往哪加 → 代码越来越乱
3

4
分模块：
5
加新功能，创建新模块 → 结构清晰

1
用户发起面试：
2
1. 检查用户配额        → User Schema
3
2. 获取用户简历        → Resume Schema
4
3. 生成面试问题        → Interview Schema
5
4. 记录消费记录        → UserTransaction Schema
6
5. 保存面试结果        → InterviewResult Schema

1
❌ 每个 Controller 都要写：
2
@UseInterceptors(ResponseInterceptor)
3
@UseFilters(AllExceptionsFilter)
4

5
结果：
6
- 50 个接口，写 50 遍
7
- 改一次，改 50 个地方
8
- 容易漏掉，不统一

1
✅ 在 main.ts 注册一次：
2
app.useGlobalInterceptors(new ResponseInterceptor())
3
app.useGlobalFilters(new AllExceptionsFilter())
4

5
结果：
6
- 写一次，处处生效
7
- 改一个地方，全部更新
8
- 不会漏，完全统一

1
❌ 改了接口，忘记更新文档
2
❌ 前端看的文档是旧的
3
❌ 前后端理解不一致
4
❌ 浪费时间对接

1
✅ 改了代码，文档自动更新
2
✅ 前端看的永远是最新的
3
✅ 前后端理解完全一致
4
✅ 可以直接在网页测试

1
1. 确定模块
2
   → 属于 InterviewModule
3

4
2. 设计数据结构（Schema）
5
   → 创建 FavoriteQuestion Schema
6
   → 字段：userId, questionId, createdAt
7

8
3. 定义接口参数（DTO）
9
   → CreateFavoriteDto: { questionId }
10
   → 返回值：{ id, questionId, createdAt }
11

12
4. 编写业务逻辑（Service）
13
   → FavoriteService.create()
14
   → 检查是否已收藏
15
   → 保存到数据库
16

17
5. 暴露接口（Controller）
18
   → POST /interview/favorite
19
   → @UseGuards(JwtAuthGuard)
20

21
6. 添加认证
22
   → 需要登录才能收藏
23

24
7. 编写文档（Swagger）
25
   → @ApiOperation({ summary: '收藏面试题' })
26
   → @ApiResponse({ status: 201, description: '收藏成功' })
27

28
8. 测试
29
   → 打开 Swagger UI
30
   → 测试接口

1
❓ 验证用户配额，写在哪里？
2
✅ 写在 Service 里（业务逻辑）
3

4
❓ 检查 Token，写在哪里？
5
✅ 用 Guard（认证逻辑）
6

7
❓ 统一响应格式，写在哪里？
8
✅ 用 Interceptor（横切关注点）
9

10
❓ 验证参数格式，写在哪里？
11
✅ 用 DTO + ValidationPipe（数据验证）
12

13
❓ 捕获错误，写在哪里？
14
✅ 用 Filter（错误处理）

1
main.ts          → 应用入口，全局配置
2
AppModule        → 根模块，组织所有功能
3
功能模块          → 按业务领域划分

1
请求进入
2
  ↓
3
验证数据（Pipe）
4
  ↓
5
验证身份（Guard）
6
  ↓
7
处理请求（Controller → Service）
8
  ↓
9
格式化响应（Interceptor）
10
  ↓
11
返回客户端

1
通过 imports 导入其他模块
2
通过 exports 导出 Service
3
通过构造函数注入使用 Service

1
关注点分离    → 每一层只做自己的事
2
单一职责      → 每个类只有一个改变的理由
3
DRY 原则      → 不要重复代码
4
依赖注入      → 让框架管理依赖