NestJS 学习指南

PandoraActor
243 阅读16分钟

📋 目录

一、框架结构与核心模块

1. Module（模块）

定义
Module 是 NestJS 应用的组织单元，负责将相关的 controller、service、provider 等资源组合在一起。每个模块可以导入其他模块，模块用 @Module() 装饰器定义。

典型用途

  • 按领域划分，如 UserModule、AuthModule、ProductModule
  • 注册控制器、服务、管道、拦截器、守卫等

Demo

import { Module } from '@nestjs/common';
import { UserService } from './user.service';
import { UserController } from './user.controller';

@Module({
  controllers: [UserController],
  providers: [UserService],
})
export class UserModule {}

UserModule 负责用户相关的 controller/service 的聚合和管理。

2. Controller（控制器）

定义
Controller 接收外部请求并响应，负责路由处理、参数解析，仅进行请求分发和结果返回，具体业务逻辑委托给 Service 层。

常用场景

  • RESTful API 路由处理
  • 请求参数校验、绑定
  • 切分业务入口

常用装饰器

  • @Controller() 定义控制器
  • @Get、@Post、@Put、@Delete 路由装饰器
  • @Body、@Param、@Query、@Headers

Demo

import { Controller, Get, Post, Param, Body } from '@nestjs/common';
import { UserService } from './user.service';

@Controller('user')
export class UserController {
  constructor(private readonly userService: UserService) {}

  @Get(':id')
  findOne(@Param('id') id: string) {
    return this.userService.findOne(+id);
  }

  @Post()
  create(@Body() dto: CreateUserDto) {
    return this.userService.create(dto);
  }
}

3. Service（服务）

定义
Service 负责封装和处理业务逻辑、数据访问等操作。由依赖注入管理，可以在 controller、provider 等处复用。

常用场景

  • 封装业务流程代码
  • 数据库 CRUD 操作
  • 对外提供可复用方法

常用装饰器

  • @Injectable()

Demo

import { Injectable } from '@nestjs/common';

@Injectable()
export class UserService {
  private users = [];

  create(user) {
    this.users.push(user);
    return user;
  }

  findOne(id: number) {
    return this.users.find((u) => u.id === id);
  }
}

4. Provider（提供者）

定义
Provider 是所有可以被依赖注入（DI）系统管理和注入的对象，常见有 Service，也支持工厂、值、已有对象、异步工厂等。

常见类型

  • 类（如 Service）
  • 工厂（useFactory）
  • 值（useValue）
  • 现有 Provider（useExisting）

Demo

@Module({
  providers: [
    UserService,
    { provide: 'API_KEY', useValue: 'my-secret-key' },
    { provide: 'CUSTOM_FACTORY', useFactory: () => new CustomClass() },
  ],
})
export class AppModule {}

场景举例：可通过字符串 token 注入常量、第三方 SDK 实例等。

5. Dependency Injection（依赖注入）

定义
依赖注入指框架自动创建并传递依赖对象，通过构造函数声明依赖，Nest 自动查找并注入对应 Provider 实例。

常用场景

  • 注入 Service 到 Controller
  • Controller、Guard、Pipe、Interceptor 等组件之间的解耦

Demo

@Injectable()
export class UserController {
  constructor(private userService: UserService) {} // 自动注入
}

只需在构造器声明类型，NestJS 会自动注入实例。

二、请求处理与管道

6. Pipe（管道）

定义
Pipe 是处理请求数据的类，可用于数据验证、类型转换、分组等，常见如参数类型转换和 DTO 校验。

常用场景

  • DTO 属性校验（ValidationPipe + class-validator）
  • 参数类型转换（如 string → number/boolean/array）
  • 业务自定义校验

常用内置管道及说明

管道用途描述示例
ValidationPipe配合 class-validator 进行 DTO 参数自动校验@Body(new ValidationPipe())
ParseIntPipe将参数字符串自动转换为 number@Param('id', ParseIntPipe)
ParseBoolPipe字符串（'true', 'false'）转为 boolean@Query('flag', ParseBoolPipe)
ParseUUIDPipe校验并格式化 UUID@Param('id', ParseUUIDPipe)
DefaultValuePipe为参数设置默认值@Query('page', new DefaultValuePipe(1))
ParseArrayPipe分割字符串或转成数组@Query('ids', new ParseArrayPipe({ items: Number }))

常用场景举例：

@Get(':id')
getUserById(@Param('id', ParseIntPipe) id: number) {
  // id 已被解析为 number 类型
}

@Post()
createUser(@Body(new ValidationPipe()) dto: CreateUserDto) {
  // dto 各字段已自动校验并转换
}

自定义管道示例：

import { PipeTransform, Injectable, ArgumentMetadata, BadRequestException } from '@nestjs/common';

@Injectable()
export class PositiveIntPipe implements PipeTransform {
  transform(value: string) {
    const val = parseInt(value, 10);
    if (isNaN(val) || val <= 0) throw new BadRequestException('必须为正整数');
    return val;
  }
}

// 使用
@Get(':id')
getById(@Param('id', PositiveIntPipe) id: number) { ... }

7. Guard（守卫）

定义
Guard 用来实现请求的权限认证与访问控制，例如身份验证、角色权限、RBAC 权限系统等。

常用内置守卫

  • AuthGuard：认证守卫，处理身份认证（如 JWT、passport 集成）
  • RolesGuard：角色校验守卫
  • 自定义业务守卫

Demo & 场景

import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';

@Injectable()
export class RoleGuard implements CanActivate {
  canActivate(context: ExecutionContext): boolean {
    // 判断请求用户角色是否有权限，示例全允许
    return true;
  }
}

// 控制器/方法层应用
@UseGuards(RoleGuard)
@Get('admin')
getAdminInfo() { ... }

常见于 API 权限、后台管理系统等。

8. Interceptor（拦截器）

定义
Interceptor 可扩展处理请求和响应（AOP），如统一响应格式、日志、缓存、请求统计、第三方追踪等。

常用内置及自定义用法

  • 响应格式化（如返回 { data, success }）
  • 操作日志埋点
  • 缓存拦截
  • 响应/错误全局包裹

自定义拦截器 Demo

import {
  Injectable,
  NestInterceptor,
  ExecutionContext,
  CallHandler,
} from '@nestjs/common';
import { Observable } from 'rxjs';
import { map } from 'rxjs/operators';

@Injectable()
export class TransformInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    return next.handle().pipe(map((data) => ({ success: true, data })));
  }
}

// 全局注册
import { APP_INTERCEPTOR } from '@nestjs/core';
providers: [{ provide: APP_INTERCEPTOR, useClass: TransformInterceptor }];

常见于统一响应体、自动包装 API 结果等场景。

9. Exception Filter（异常过滤器）

定义
Exception Filter 统一处理异常、格式化错误响应，覆盖默认的 500 错误返回，便于前端统一处理。

常用内置或自定义

  • HttpExceptionFilter：捕获并自定义处理所有 HTTP 异常
  • AllExceptionsFilter：捕获任意类型异常

Demo

import {
  ExceptionFilter,
  Catch,
  ArgumentsHost,
  HttpException,
} from '@nestjs/common';

@Catch(HttpException)
export class HttpErrorFilter implements ExceptionFilter {
  catch(exception: HttpException, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse();
    const status = exception.getStatus();
    response.status(status).json({
      statusCode: status,
      message: exception.message,
      timestamp: new Date().toISOString(),
    });
  }
}

// 全局注册
import { APP_FILTER } from '@nestjs/core';
providers: [{ provide: APP_FILTER, useClass: HttpErrorFilter }];

常见于微服务、API 统一错误封装

10. Middleware（中间件）

定义
Middleware 在请求到达 Controller 之前执行，适合日志、请求增强、权限校验等横切逻辑。

常用中间件类型

  • 日志记录（Logger）
  • 请求计数/限流
  • 权限前置拦截
  • 全局 Request 头检查

Demo

import { Injectable, NestMiddleware } from '@nestjs/common';

@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  use(req: any, res: any, next: () => void) {
    console.log(`Request path:`, req.originalUrl);
    next();
  }
}

// 应用到模块
import { MiddlewareConsumer, Module, RequestMethod } from '@nestjs/common';

@Module({})
export class AppModule {
  configure(consumer: MiddlewareConsumer) {
    consumer
      .apply(LoggerMiddleware)
      .forRoutes({ path: '*', method: RequestMethod.ALL });
  }
}

11. DTO（数据传输对象）

定义
DTO 用于明确和限制接口输入输出数据结构，并结合 class-validator 实现属性级校验。

常用场景

  • 入参、出参的数据校验和格式定义
  • Swagger 文件自动生成文档
  • 保证 Controller/Service 数据安全

典型属性装饰器

  • @IsString()
  • @IsNumber()
  • @IsEmail()
  • @IsOptional() 等

Demo

import { IsString, IsEmail, IsOptional } from 'class-validator';

export class CreateUserDto {
  @IsEmail()
  email: string;

  @IsString()
  password: string;

  @IsOptional()
  @IsString()
  avatar?: string;
}

// 控制器使用
@Post()
createUser(@Body() dto: CreateUserDto) { ... }

三、系统通用支持

12. Logger（日志系统）

NestJS 内置日志系统简介
NestJS 提供了内置的 Logger 类，实现了分级日志、格式化输出，可便捷记录 info、warn、error、debug、verbose 等日志。适用于绝大多数开发场景。

内置 Logger 用法

常用场景

  • 打印请求、异常、业务行为等
  • 快速分类/过滤日志
  • 日志与依赖注入结合

Demo

import { Logger, Injectable } from '@nestjs/common';

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

  doSomething() {
    this.logger.log('普通信息'); // info
    this.logger.warn('警告信息'); // warn
    this.logger.error('错误信息', new Error('异常'));
    this.logger.debug('调试信息'); // debug
    this.logger.verbose('详细日志'); // verbose
  }
}

主入口一般这样配置日志级别（main.ts）：

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { Logger } from '@nestjs/common';

async function bootstrap() {
  const app = await NestFactory.create(AppModule, {
    logger: ['log', 'error', 'warn', 'debug', 'verbose'], // 可自定义
  });
  await app.listen(3000);
  Logger.log('Application started');
}
bootstrap();

集成 winston 第三方日志

简介
winston 是 Node.js 社区流行的日志库，支持日志持久化（如文件/远端）、格式自定义、日志分组、多 transport（控制台、文件、HTTP等）。

应用场景

  • 生产环境日志切片/归档
  • 与 ELK/Sentry 等日志平台联动
  • 日志 JSON 格式、日志留存

NestJS 集成 winston 步骤

推荐配合 nestjs-winston 包

1. 安装依赖

npm install winston nest-winston

2. 集成和简单 Demo

// main.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { WinstonModule } from 'nest-winston';
import * as winston from 'winston';

async function bootstrap() {
  const app = await NestFactory.create(AppModule, {
    logger: WinstonModule.createLogger({
      transports: [
        new winston.transports.Console({
          format: winston.format.combine(
            winston.format.timestamp(),
            winston.format.simple(),
          ),
        }),
        new winston.transports.File({
          filename: 'error.log',
          level: 'error',
          format: winston.format.json(),
        }),
      ],
    }),
  });

  await app.listen(3000);
}
bootstrap();

3. 依赖注入使用 winston 实例

import { Injectable, LoggerService } from '@nestjs/common';
import { WINSTON_MODULE_NEST_PROVIDER } from 'nest-winston';

@Injectable()
export class YourService {
  constructor(
    @Inject(WINSTON_MODULE_NEST_PROVIDER)
    private readonly logger: LoggerService,
  ) {}

  someMethod() {
    this.logger.log('普通 info');
    this.logger.error('出错啦！', new Error('bad'));
  }
}

开发/测试阶段建议优先用 Nest 内置 Logger，生产和合规日志输出建议集成 winston 或同类库。

13. ConfigModule（配置模块）

定义
@nestjs/config 提供环境变量及应用配置的集中化管理。用于读取 .env 文件，并将配置以服务注入使用。

常用场景

  • 读取数据库、第三方服务等敏感配置
  • 多环境自动切换（开发/生产）

Demo

// app.module.ts
import { Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';

@Module({
  imports: [
    ConfigModule.forRoot({
      isGlobal: true, // 全局可用
      envFilePath: '.env',
    }),
  ],
})
export class AppModule {}

// 使用
import { ConfigService } from '@nestjs/config';

@Injectable()
export class SomeService {
  constructor(private config: ConfigService) {
    const dbHost = this.config.get('DB_HOST');
  }
}

14. 全局能力注册

用途说明
可通过 @nestjs/core 的 token，将 Pipe/Guard/Filter/Interceptor 单例全局化，无需控制器逐个标记。

Demo

import { APP_GUARD, APP_PIPE } from '@nestjs/core';

@Module({
  providers: [
    { provide: APP_GUARD, useClass: RolesGuard },
    { provide: APP_PIPE, useClass: ValidationPipe },
  ],
})
export class AppModule {}

四、核心扩展能力

15. 静态资源与文件上传

静态资源
可使用 ServeStaticModule 对外暴露静态文件夹（如上传、图片、前端页面）。

Demo

import { Module } from '@nestjs/common';
import { ServeStaticModule } from '@nestjs/serve-static';
import { join } from 'path';

@Module({
  imports: [
    ServeStaticModule.forRoot({
      rootPath: join(__dirname, '..', 'public'), // 静态目录
    }),
  ],
})
export class AppModule {}

文件上传
利用 @nestjs/platform-express 的 FileInterceptor 实现文件上传。

import {
  Controller,
  Post,
  UploadedFile,
  UseInterceptors,
} from '@nestjs/common';
import { FileInterceptor } from '@nestjs/platform-express';

@Controller('upload')
export class UploadController {
  @Post()
  @UseInterceptors(FileInterceptor('file'))
  upload(@UploadedFile() file: Express.Multer.File) {
    return { filename: file.originalname };
  }
}

16. Swagger 自动接口文档

定义
@nestjs/swagger 可自动根据 DTO 输出规范化 OpenAPI 接口文档，前后端协作极大提升。

Demo

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  const config = new DocumentBuilder()
    .setTitle('Demo API')
    .setDescription('接口文档示例')
    .setVersion('1.0')
    .build();
  const document = SwaggerModule.createDocument(app, config);
  SwaggerModule.setup('docs', app, document);
  await app.listen(3000);
}
bootstrap();

在 http://localhost:3000/docs 可以访问自动生成的 Swagger 文档。

17. Schedule（定时任务）

定义
@nestjs/schedule 提供基于 cron 或 interval 的定时任务编写能力。

Demo

import { Injectable } from '@nestjs/common';
import { Cron, Interval } from '@nestjs/schedule';

@Injectable()
export class TasksService {
  @Cron('0 0 * * *')
  handleCron() {
    // 每天零点任务
  }

  @Interval(60000)
  handleInterval() {
    // 每60秒执行
  }
}

18. Event（事件总线）

定义
@nestjs/event-emitter 支持轻量的事件发布与订阅模式，实现解耦触发机制。

Demo

import { Injectable } from '@nestjs/common';
import { OnEvent, EventEmitter2 } from '@nestjs/event-emitter';

@Injectable()
export class UserEventsListener {
  @OnEvent('user.created')
  handleUserCreated(payload: any) {
    // 用户创建事件处理
  }
}

// 使用
@Injectable()
export class UserService {
  constructor(private eventEmitter: EventEmitter2) {}
  async createUser() {
    // ...创建逻辑
    this.eventEmitter.emit('user.created', { userId: 1 });
  }
}

19. 生命周期钩子

简介
NestJS 生命周期包括 OnModuleInit、OnApplicationBootstrap 等钩子，用于模块初始化和应用启动后自定义逻辑。

应用场景

  • 连接外部服务（如数据库、缓存、第三方 API）
  • 预加载数据、任务队列初始化

Demo

import { Injectable, OnApplicationBootstrap } from '@nestjs/common';

@Injectable()
export class MyAppService implements OnApplicationBootstrap {
  async onApplicationBootstrap() {
    // 应用启动后自定义逻辑
  }
}

五、数据与中间件集成

20. TypeORM 数据库集成

概念说明
TypeORM 是一个支持 TypeScript 的 ORM（对象关系映射）框架，能让你用类和实体关联数据库表，并通过 Repository API 实现增删改查等操作。常用于 NestJS、Express 等 Node.js 服务端开发。

  • 支持迁移管理、事务、eager/lazy 加载等
  • 与主流关系型数据库兼容（如 MySQL、PostgreSQL 等）

安装依赖
以 MySQL 为例：

npm install typeorm mysql2 @nestjs/typeorm

模块配置与使用 Demo

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

@Entity()
export class User {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  email: string;

  @Column()
  password: string;
}

// app.module.ts
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { User } from './user.entity';

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'mysql',
      host: 'localhost',
      port: 3306,
      username: 'root',
      password: 'yourpassword',
      database: 'testdb',
      entities: [User],
      synchronize: true, // 生产环境建议为 false
    }),
    TypeOrmModule.forFeature([User]),
  ],
})
export class AppModule {}

// user.service.ts
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { User } from './user.entity';

@Injectable()
export class UserService {
  constructor(@InjectRepository(User) private userRepo: Repository<User>) {}

  async create(email: string, password: string) {
    const user = this.userRepo.create({ email, password });
    return this.userRepo.save(user);
  }

  async findAll() {
    return this.userRepo.find();
  }
}

核心操作说明

  • @Entity() 定义表，@Column() 定义表字段
  • repository 提供 .find()、.save()、.update()、.delete() 等常用方法
  • 通过 TypeOrmModule.forRoot 配置数据库连接

21. Prisma 数据库集成

概念说明
Prisma 是现代 Node.js/TypeScript ORM。通过 schema 文件（prisma/schema.prisma）声明数据模型，并生成类型安全的数据访问客户端。常见于 NestJS/Express 等应用，支持代码提示、更精细的数据库管理和迁移。

  • 代码优先、类型安全、易维护
  • 强化关系建模和查询能力，适合复杂业务逻辑

安装依赖

npm install @prisma/client
npm install -D prisma
npx prisma init # 生成 prisma/schema.prisma

schema.prisma 示例

// prisma/schema.prisma
generator client {
  provider = "prisma-client-js"
}
datasource db {
  provider = "mysql"
  url      = "mysql://root:yourpassword@localhost:3306/testdb"
}

model User {
  id       Int    @id @default(autoincrement())
  email    String @unique
  password String
}

然后运行迁移和生成客户端：

npx prisma migrate dev --name init
npx prisma generate

使用 PrismaClient 进行数据库操作

// user.service.ts
import { Injectable, OnModuleInit } from '@nestjs/common';
import { PrismaClient } from '@prisma/client';

@Injectable()
export class UserService extends PrismaClient implements OnModuleInit {
  async onModuleInit() {
    await this.$connect();
  }

  async create(email: string, password: string) {
    return this.user.create({
      data: { email, password },
    });
  }

  async findAll() {
    return this.user.findMany();
  }
}

核心操作说明

  • 定义 schema 后自动生成 PrismaClient，类型安全、方法丰富
  • .user.findMany() 、.user.create() 等全部带类型推导
  • 支持迁移、种子数据、事务、分页、复杂关联等

TypeORM vs Prisma 基本比较

特性TypeORMPrisma
配置数据模型方式装饰器类(Entity)schema.prisma 声明式为主
数据表到代码映射灵活度较高，Entity直接扩展较强，生成类型安全客户端
迁移管理支持，命令多，有一定学习曲线强大，流程简单，类型推导好
社区生态/适配star 多，NestJS 常见近年非常火，功能创新，文档完善

一般建议在需要轻量 ORM、快速开发场景用 TypeORM；在希望类型推导、强数据一致性、复杂查询的项目推荐 Prisma。

22. Redis 缓存集成

简介
Redis 是高性能的键值型内存数据库，常用于缓存、排行榜、消息队列、会话存储等。

安装

npm install ioredis @nestjs-modules/ioredis

NestJS 集成 Redis 示例

// app.module.ts
import { Module } from '@nestjs/common';
import { RedisModule } from '@nestjs-modules/ioredis';

@Module({
  imports: [
    RedisModule.forRoot({
      config: {
        host: 'localhost',
        port: 6379,
      },
    }),
  ],
})
export class AppModule {}

注入并使用 Redis 客户端

import { Injectable } from '@nestjs/common';
import { InjectRedis, Redis } from '@nestjs-modules/ioredis';

@Injectable()
export class CacheService {
  constructor(@InjectRedis() private readonly redis: Redis) {}

  async setCache(key: string, value: string) {
    await this.redis.set(key, value, 'EX', 60); // 设置60秒过期
  }

  async getCache(key: string) {
    return await this.redis.get(key);
  }
}

常见用途

  • 用户登录状态、会话管理
  • 接口数据缓存，防止击穿
  • 排行榜、计数等高性能读写场景

六、开发规范与实用建议

核心概念总结表

概念主要职责常用示例/推荐用途
Module聚合资源模块化各业务领域模块（如 UserModule）
Controller处理请求响应路由、参数解析、HTTP处理
Service业务逻辑和数据处理数据库增删查改、逻辑复用
Provider注入一切对象，扩展构造方式Service，常量，工厂等
DI依赖解耦、自动注入Controller/Service/Guard 中均可用
Pipe数据转换、参数校验ValidationPipe，ParseIntPipe 等
Guard认证授权控制AuthGuard, RolesGuard
Interceptor响应包裹、日志、缓存、异常统一处理TransformInterceptor, CacheInterceptor
ExceptionFilter统一异常捕获和响应格式化HttpErrorFilter, AllExceptionsFilter
Middleware请求前置处理（日志、权限、拦截等）LoggerMiddleware
DTO明确和校验接口数据结构CreateUserDto, UpdateUserDto

开发规范建议

  • 严格按领域分层建立 module/service/controller
  • 充分利用 TypeScript 类型和 NestJS 装饰器
  • 配置与敏感信息集中管理，不混杂进业务代码
  • 日志/异常处理全局化并与平台日志集成
  • 各项扩展（如定时任务、Swagger、文件上传）按需引入、分模块单元测试
  • 推荐使用自动化接口文档 + 统一错误返回格式

建议研读顺序

  1. 框架主干（Module/Controller/Service）
  2. 依赖注入与 provider 配置
  3. Pipe/Guard/Interceptor/ExceptionFilter
  4. 系统配置与日志
  5. 文件/静态资源、Swagger
  6. 定时任务或事件机制
  7. ORM/ODM 与缓存中间件集成
  8. 项目结构、分层及高阶技巧

七、常见问题与学习建议

常见问题

1. Node/NestJS 运行机制简要区别

  • Node 是单线程事件循环模型，NestJS 建构于 Node/Express 之上，用装饰器风格实现分层、依赖注入等，逻辑和前端框架架构类似（有 Module、Service、Controller 概念）。
  • 熟练掌握 ES6+、Promise/async-await 有助于理解服务端开发。

2. 数据库 & ORM 基础知识

  • SQL 基本语句：select、insert、update、delete、where、join 等。
  • ORM 常用操作（如 TypeORM/Prisma）：增删查改、事务、分页、条件查询、关联查询。

3. 身份认证与鉴权

  • 建议了解 JWT、Session 区别。
  • 认证流程（登录、token 生成与解析、接口如何做用户身份校验）。

4. RESTful API 规范

  • 路径设计、请求方法（GET/POST/PUT/DELETE/PATCH）用途。
  • 推荐学习接口参数（query/body/path）、响应结构统一范式。

5. 错误处理 & 日志

  • NestJS 提供统一异常捕获（ExceptionFilter），日志（Logger）机制，开发和线上模式建议区分处理。
  • 概念类似前端 try/catch + window.onerror，但细粒度更高。

6. 热重载 & 调试技巧

  • 开发可以用 npm run start:dev 实现热重载。
  • vscode 插件（如 REST Client/Postman/Thunder Client）做接口调试。
  • 打断点/日志辅助定位。

学习建议

  • 推荐先跟官方文档/入门项目走一遍，结合视频资料（B 站/YouTube 用「nestjs 入门」关键词）。
  • 多写简单 CRUD，不懂就搜 Controller、Service、DTO、Provider 的例子。
  • 遇到通用中间件、全局异常、定时任务、第三方服务集成时，建议查相关官方扩展模块的 Demo，遇到问题多看 type 和自动提示。
  • 推荐配合 Postman/Insomnia 练习调接口，形成流畅的「开发-测试-修改」闭环。
  • 学习 NestJS 其实就是学会「服务端分层设计思想」，把 MVC/解耦/注入/配置项玩熟，后续切框架（如 Koa/Express/Java Spring）原理都类似。

通过模块化、管道、守卫、拦截器、异常过滤器、中间件和 DTO 等机制，NestJS 提供了高度解耦、可维护、可扩展的后端开发架构。掌握这些核心概念和常用实现，对于编写健壮与规范的后端 API 至关重要。

avatar
文章
阅读
粉丝