Nest入门 | 别来无恙

路由与控制器

路由路径匹配规则

// 主路径为 home
@Controller("home")

// 1. 固定路径
// 可匹配到的访问路径：
//   http://localhost:3000/home/greeting
@Get("greeting")

// 2. 通配符路径(通配符可以有 ?, +, * 三种)
// 可匹配到的访问路径：
//   http://localhost:3000/home/say_hi
//   http://localhost:3000/home/say_hello
//   http://localhost:3000/home/say_good
//   ...
@Get("say_*")

// 3. 路径数组
// 可匹配到的访问路径：匹配上面1和2里的所有路径
@Get(["greeting", "say_*"])

// 4. 带参路径
// 可匹配到的访问路径：
//   http://localhost:3000/home/greeting/hello
//   http://localhost:3000/home/greeting/good-morning
//   http://localhost:3000/home/greeting/xxxxx
//   ...
@Get("greeting/:words")

标准模式和特定库模式

这样一段请求

url

http://localhost:3000/home/greeting?from=hello

标准模式下获取参数的代码

import { Controller, Get, Query } from '@nestjs/common'

@Controller('home')
export class AppController {
  @Get('greeting')
  getHello(@Query('from') from: string): string {
    return `A greeting from ${from}`
  }
}

特定库模式(express)下获取参数的代码

import { Controller, Get, Req, Res } from '@nestjs/common'
import { Request, Response } from 'express'

@Controller('home')
export class AppController {
  @Get('greeting')
  getHello(@Req() req: Request, @Res() res: Response) {
    const { from } = req.query
    res.send(`A greeting from ${from}`)
  }
}

其他常用装饰器的功能

@Param - 路径动态参数装饰器

url

http://www.myblog.com/articles/20191110
http://www.myblog.com/articles/20191111
http://www.myblog.com/articles/20191112

import { Controller, Get, Param } from '@nestjs/common'

@Controller('articles')
export class ArticleController {
  @Get(':date')
  getArticles(@Param('date') date: string): string {
    return `Articles for ${date}`
  }
}

@Post + @Body - 获取 POST 请求的请求体

获取 body 数据

test

{
  "title": "你好！",
  "content": "世界。"
}

interface CreateArticleDto {
    title: string;
    content: string;
}

// ....

@Post()
async create(@Body() article: CreateArticleDto) {
  console.log(article); // {"title": "你好！","content": "世界。"}
  this.articleService.create(article);
  return 'New article is created';
}

//使用@Header装饰器添加响求头信息使用
//@Headers获取请求头信息
@Post("test")
@Header('Access-Control-Allow-Origin', '*')
test(@Headers("Authorization ") token: string) {
  return `Authorization  is ${token}`
}

面向切面编程

面向切面编程（Aspect Oriented Programming，简称 AOP）主要是针对业务处理过程中的切面进行提取，在某个步骤和阶段进行一些操作，从而达到 DRY（Don't Repeat Yourself）的目的。AOP 对 OOP 来说，是一种补充，比如可以在某一切面中对全局的 Log、错误进行处理，这种一刀切的方式，也就意味着，AOP 的处理方式相对比较粗粒度。在 Nestjs 中，AOP 分为下面几个部分（按顺序排列）：
1. Middlewares
2. Guards
3. Interceptors (在流被操纵之前)
4. Pipes
5. Interceptors (在流被操纵之后)
6. Exception filters (如果发现任何异常)

Middlewares(中间件)

Middleware 和 express 的中间件一样，可以直接使用 express 中的中间件

//main.ts

//helmet 是一个包括了 12 个中间件，用来设置一些安全的 headers 的集合。
import * as helmet from 'helmet'

async function bootstrap() {
  const app = await NestFactory.create<NestExpressApplication>(AppModule, {
    cors: true,
    logger: false,
  })

  app.use(helmet())

  await app.listen(config.port, config.hostName, () => {
    Logger.log(`Flash API server has been started on http://${config.hostName}:${config.port}`)
  })
}

Guards(守卫)

Guards 和前端路由中的路由守卫一样，主要确定请求是否应该由路由处理程序处理。通过守卫可以知道将要执行的上下文信息，所以和 middleware 相比，守卫可以确切知道将要执行什么。
守卫在每个中间件之后执行的，但在拦截器和管道之前。

//service.ts
import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common'
import { Observable } from 'rxjs'

//使用implements约束类的实现
@Injectable()
export class AuthGuard implements CanActivate {
  canActivate(context: ExecutionContext): boolean | Promise<boolean> | Observable<boolean> {
    const request = context.switchToHttp().getRequest()
    // validateRequest 函数实现 Request 的验证
    return validateRequest(request)
  }
}

Interceptors(拦截器)

Interceptors 可以给每一个需要执行的函数绑定，拦截器将在该函数执行前或者执行后运行。可以转换函数执行后返回的结果，扩展基本函数行为等。

//service.ts
import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common'
//rxjs: 用于 JavaScript 的 ReactiveX 库。 RxJS 是使用 Observables 的响应式编程的库，它使编写异步或基于回调的代码更容易。
import { Observable } from 'rxjs'
import { map } from 'rxjs/operators'
import { getFormatResponse } from '../../shared/utils/response'

export interface Response<T> {
  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(getFormatResponse))
  }
}

Pipes(管道)

Pipe 是具有 @Injectable() 装饰器的类，并实现了 PipeTransform 接口。通常 pipe 用来将输入数据转换为所需的输出或者处理验证。

//这是一个 ValidationPipe， 会根据元数据和对象实例，去构建原有类型，然后配合DTO 中的 class-validator 和 class-transformer ，可以更方便地对参数进行校验。
import { PipeTransform, ArgumentMetadata, BadRequestException, Injectable } from '@nestjs/common'
import { validate } from 'class-validator'
import { plainToClass } from 'class-transformer'

@Injectable()
export class ValidationPipe implements PipeTransform<any> {
  async transform(value, metadata: ArgumentMetadata) {
    const { metatype } = metadata
    if (!metatype || this.toValidate(metatype)) {
      return value
    }
    const object = plainToClass(metatype, value)
    const errors = await validate(object)
    if (errors.length > 0) {
      throw new BadRequestException('Validation failed')
    }
    return value
  }

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

//这个 pipe 一般会作为全局的 pipe 去使用,假设我们没有这层 pipe，那在 controller 中就会进行参数校验，这样就会打破单一职责的原则。有了这一层 pipe 帮助我们校验参数，有效地降低了类的复杂度，提高了可读性和可维护性。
//main.ts
async function bootstrap() {
  const app = await NestFactory.create(ApplicationModule)
  app.setGlobalPrefix('api/v1')

  app.useGlobalPipes(new ValidationPipe())

  await app.listen(3000)
}
bootstrap()

Exception filters(异常处理)

内置的 Exception filters 负责处理整个应用程序中的所有抛出的异常，也是 Nestjs 中在 response 前，最后能捕获异常的机会。

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

@Catch()
export class AnyExceptionFilter implements ExceptionFilter {
  catch(exception: any, host: ArgumentsHost) {
    const ctx = host.switchToHttp()
    const response = ctx.getResponse()
    const request = ctx.getRequest()

    response.status(status).json({
      statusCode: exception.getStatus(),
      timestamp: new Date().toISOString(),
      path: request.url,
    })
  }
}

利用 AOP 的思想使用 Interceptor 和 Exception Filter 去处理全局错误

Interceptor 会在 Exception Filter 之前触发，所以 Exception Filter 会是最后捕获 exception 的机会。

//全局捕获错误的切片层去处理所有的 exception；
import { Catch, ArgumentsHost, HttpException, ExceptionFilter, HttpStatus } from '@nestjs/common'

@Catch()
export class ExceptionsFilter implements ExceptionFilter {
  async catch(exception, host: ArgumentsHost) {
    const ctx = host.switchToHttp()
    const response = ctx.getResponse()
    const request = ctx.getRequest()

    let message = exception.message
    let isDeepestMessage = false
    while (!isDeepestMessage) {
      isDeepestMessage = !message.message
      message = isDeepestMessage ? message : message.message
    }

    const errorResponse = {
      message: message || '请求失败',
      status: 1,
    }

    const status =
      exception instanceof HttpException ? exception.getStatus() : HttpStatus.INTERNAL_SERVER_ERROR

    response.status(status)
    response.header('Content-Type', 'application/json; charset=utf-8')
    response.send(errorResponse)
  }
}

// Interceptor 则负责对成功请求结果进行包装：
import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common'
import { Observable } from 'rxjs'
import { map } from 'rxjs/operators'

interface Response<T> {
  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(rawData => {
        return {
          data: rawData,
          status: 0,
          message: '请求成功',
        }
      })
    )
  }
}

// Interceptor 和 Exception Filter 需要把它定义在全局范围内
async function bootstrap() {
  const app = await NestFactory.create(AppModule)
  app.setGlobalPrefix('api/v1')

  app.useGlobalFilters(new ExceptionsFilter())
  app.useGlobalInterceptors(new TransformInterceptor())
  app.useGlobalPipes(new ValidationPipe())

  await app.listen(3000)
}

NestJS 中依赖注入

基于 IoC(Inversion of Control 控制反转) 框架的应用程序开发中，我们编写的代码都依赖于这个容器，容器管理着代码中各个对象间的关联关系，为它们注入需要的外部资源。容器最适合管理的资源是那些具有高可复用性的内容，如：配置信息、全局常量、可复用的业务逻辑组件、以及工具类等等。
在使用了依赖注入功能的程序中，从资源的角度，可以把代码中的对象角色分为以下 3 种：
- 容器(module) - 是所有资源的管理者。程序中可被注入的资源都由容器来发起创建和维护其生命周期
- 资源提供者(service) - 资源创建的实际执行者。所有的资源提供者都需要在容器进行注册登记，然后由容器来进行统一调度
- 资源使用者(controller) - 就是那些需要使用到容器中管理的那些资源的消费者了有些情况下，资源提供者本身即是提供者也是使用者。记住一点，只要依赖于其他资源的对象，它就是一个资源使用者。
NestJS 命令行工具提供的代码生成器功能，可以帮我们快速生成一个模块（Module）代码文件。
1. 在 Nest 项目下执行nest g module product后，可以看到项目的 src 目录下多了一个 product 子目录，且下面生成了一个名为 product.module.ts 的模块代码文件。
2. 执行命令nest g service product, 可以在 product 目录下生成了一个名为 product.service.ts 的文件，以及一个同名的 spec 文件，前者就是一个典型的类资源提供者，后者是它对应的单元测试类。
3. 执行命令nest g co product,可以在 product 目录又生成了一个名为 product.controller.ts 的文件，以及一个同名的 spec 文件。
在 MVC 模式中，controller 通过 model 获取数据。对应的，在 Nestjs 中，controller 负责处理传入的请求，并调用对应的 service 完成业务处理，返回对客户端的响应。
如果需要在所有请求之前加上 prefix，可以在 main.ts 中直接设置 GlobalPrefix

//main.ts
import { NestFactory } from '@nestjs/core'
import { AppModule } from './app.module'

async function bootstrap() {
  const app = await NestFactory.create(AppModule)
  app.setGlobalPrefix('api/v1')
  await app.listen(3000)
}
bootstrap()

Nest 中一个容器注入的例子

步骤一：将 Car 类使用 @Injectable 装饰器，声明成其可被容器进行注入的资源

// car.ts

import { Injectable } from '@nestjs/common'

@Injectable()
export class Car {
  constructor(private readonly name: string) {}

  start() {
    console.log(`Your ${this.name} is start running!`)
  }
}

步骤二：通过构造函数，注入需要使用 Car 的类中

// app.controller.ts

import { Controller, Get } from '@nestjs/common'
import { Car } from './car'

@Controller()
export class AppController {
  constructor(
    // 自动注入Car对象
    private readonly car: Car
  ) {}

  @Get('test/car')
  testCar(): string {
    // 控制台打印car的内容
    console.log(this.car) //Car { name: '保时捷911' }
    // 调用car对象的方法
    this.car.start() //Your 保时捷911 is start running!
    return 'test done!'
  }
}

步骤三：在模块配置中，配置 Car 类的对象提供器(将 Car 类注入容器中使其可被 controller 注入)

// app.module.ts

import { Module } from '@nestjs/common'
import { AppController } from './app.controller'
import { AppService } from './app.service'
import { Car } from './car'

@Module({
  imports: [],
  controllers: [AppController],
  providers: [
    // 配置一辆保时捷
    {
      provide: Car,
      useFactory: () => {
        return new Car('保时捷911')
      },
    },
  ],
})
export class AppModule {}

资源提供者

在 NestJS 框架中，基础类型值、对象、函数等，都可以被作为资源来使用。在代码中要使用这些资源，需要经过一种中间者来创建和提供：资源提供者（Providers）。
NestJS 中的资源提供者主要分为 4 种类型

一、使用类作为提供者，称为 ClassProvider

它也是我们日常开发中会最经常用到的一种资源提供者。一个普通的类，通过添加 @Injectable 装饰器，就可以成为一个资源提供者。
资源提供者是需要先经过注册之后才能被容器所使用。资源提供者的注册工作是在模块（Module）中进行的。

//product.service.ts
import { Injectable } from '@nestjs/common'

@Injectable()
export class ProductService {
  getProducts(): string[] {
    return ['iPhone 11', 'iPhone 11 pro', 'iPhone 11 pro max']
  }
}

//product.module.ts
import { Module } from '@nestjs/common'
import { ProductService } from './product.service'

@Module({
  //简写
  // providers: [ProductService],

  //完整写法
  //provide 属性被称为注入令牌（Injection Token），类似于像在 Map 中存储值时的 key
  //useClass 则用于指定生成资源实例的类。
  providers: [
    {
      provide: ProductService,
      useClass: ProductService,
    },
  ],
})
export class ProductModule {}

二、使用常量值（可以是简单基础类型值，也可以是对象），称为 ValueProvider

适用于做配置性的工作，或者是 Mock 测试。

import { Module } from '@nestjs/common'
import { ProductService } from './product.service'

//全局配置
@Module({
  providers: [
    ProductService,
    {
      provide: 'AUTHOR_NAME',
      useValue: '全局常量注入',
    },
  ],
}) //Mock // Mock对象
const myProductService = {
  getProducts() {
    return ['iPhone 4', 'iPhone 4s']
  },
}

@Module({
  providers: [
    {
      provide: ProductService,
      // 使用Mock对象来替代原先通过ProductService类生成的对象
      useValue: myProductService,
    },
  ],
})
export class ProductModule {}

三、使用工厂函数，称为 FactoryProvider

适用于需要更为动态的创建资源的场景。

//product.service.ts
import { Injectable } from '@nestjs/common'

@Injectable()
export class ProductService {
  // 构造函数，接受一个 author参数
  constructor(private readonly author: string) {}
  getProducts(): string[] {
    return ['iPhone 11', 'iPhone 11 pro', 'iPhone 11 pro max']
  }
}

//product.module.ts
import { Module } from '@nestjs/common'
import { ProductService } from './product.service'

@Module({
  providers: [
    {
      provide: 'AUTHOR_NAME',
      useValue: '全局常量注入',
    },
    {
      provide: ProductService,
      // 工厂函数
      useFactory: (author: string) => {
        return new ProductService(author)
      },
      // 注入其他资源作为工厂函数参数，可通过this.AUTHOR_NAME获取到上面的值
      inject: ['AUTHOR_NAME'],
    },
  ],
  exports: [ProductService],
})
export class ProductModule {}

四、用于给其他已有的资源提供者创建其他别名的方式，称为 ExistingProvider

import { Module } from '@nestjs/common'
import { ProductService } from './product.service'

@Module({
  providers: [
    // 一个class类提供者
    ProductService,
    // 上面的提供者的别名
    {
      provide: 'AliasedProductService',
      useExisting: ProductService,
    },
  ],
})
export class ProductModule {}

资源注入方式

在依赖注入框架中，资源通过容器的调度，被注入到资源使用者内。在 NestJS 中，我们的资源使用者都是以类的形式存在的，所以资源的注入方式存在以下 2 种可能：
1. 通过类的构造函数注入
2. 通过类的属性注入

// 通过构造函数的方式
@Injectable()
export class CategoryService {
  constructor(private readonly productService: ProductService) {}
}

//如果资源的注入令牌不是 class 类型的，则需要显式的使用 @Inject 装饰器来指定
@Injectable()
export class CategoryService {
  constructor(
    @Inject('myProductService')
    private readonly productService: ProductService
  ) {}
}
//另一种可选途径，通过属性注入
@Injectable()
export class CategoryService {
  @Inject('myProductService')
  private readonly productService: ProductService
}

值得注意的是，当你的代码中指定了资源注入，而容器中却并没有相应资源的时候，程序会报错。但有时候你的代码期望这样工作：如果程序中提供了配置信息，则使用该配置信息，否则使用默认配置信息。这种情况下，作为注入资源的配置信息显然是可选的，即使没有，程序也不该出错。NestJS 当然考虑到了这一点，它提供了 @Optional 装饰器来满足上述场景：

@Injectable()
export class CategoryService {
  constructor(
    @Optional()
    @Inject('myProductService')
    private readonly productService: ProductService
  ) {}
}

依赖注入边界

在日常开发中也会遇到，但不是那么高频的依赖问题:
1. 异步资源提供者
2. 循环依赖问题与解决方式
3. 注入范围

异步资源提供者

在资源创建的时候，存在异步的环节。例如在创建资源的时候，需要先访问一个后端 API 来获取一些配置信息，然后根据这些配置信息再做进一步的资源创建。这里的后端 API 访问就是一个异步的动作，这会导致整个资源创建流程也是异步的了。
在 NestJS 中，大多数的资源提供者都是只支持同步，比如 ValueProvider 和 ClassProvider，能支持异步的只有 FactoryProvider。

{
  provide: ProductService,
  //将原先 useFactory 指定的工厂函数声明成 async 方式的函数，就可以支持异步的创建流程了。
  useFactory: async () => {
    // 调用远程接口获取信息
    const configInfo = await getProductServiceConfig()

    // 根据远程返回的数据作进一步实例化
    if (configInfo.category) {
      return new ProductService(configInfo.category)
    } else {
      return new ProductService()
    }
  }
}

循环依赖问题与解决方式

所谓的循环依赖，就是指两个类之间存在互相依赖的情况，例如：资源 A 依赖资源 B，资源 B 也需要依赖 A，这种情况下，无论是在创建 A 还是创建 B 的时候，其实彼此都还不存在，也就是互相找不到对方来满足依赖，这就会发生错误。
在模块之间或提供者之间的嵌套都可能会出现循环依赖关系。通常情况下，我们在设计的时候应该尽量避免循环依赖，但是总有避免不了的情况，在 NestJS 中提供了一种称为前向引用 (forward referencing) 的技术来解析循环依赖项。

//serviceA
@Injectable()
export class CategoryService {
  constructor(
    @Inject(forwardRef(() => ProductService))
    private readonly productService: ProductService
  ) {}
}

//serviceB
@Injectable()
export class ProductService {
  constructor(
    @Inject(forwardRef(() => CategoryService))
    private readonly categoryService: CategoryService
  ) {}
}

以上的 2 个类之间有互相依赖关系，各自需要注入对方。如果未使用代码中 NestJS 框架提供的 forwardRef () 工具函数，就会报错提示找不到依赖的资源；而使用后，容器可以正确处理互相使用 forwardRef () 函数标记过的类。

该工具函数也可作用于 2 个模块之间，解决模块间的循环依赖：

//moduleA
@Module({
  imports: [forwardRef(() => CategoryModule)],
})
export class ProductModule {}

//moduleB
@Module({
  imports: [forwardRef(() => ProductModule)],
})
export class CategoryModule {}

除了使用上面提到的 forwardRef () 工具函数，NestJS 还另外提供了一种可行的方式来解决循环依赖，那就是模块引用（Module Reference）。模块引用解决问题的思路是：不通过容器的自动依赖注入，而由我们自己来控制。

通过在类中注入框架提供的 ModuleRef，并在模块初始化的生命周期函数中进行手动查找所需要的资源实例，就能避免自动注入时的尴尬问题：

import { Injectable, OnModuleInit } from '@nestjs/common'
import { ProductService } from './product.service'
import { ModuleRef } from '@nestjs/core'

@Injectable()
export class CategoryService implements OnModuleInit {
  private productService: ProductService

  // 注入框架提供的ModuleRef实例
  constructor(private readonly moduleRef: ModuleRef) {}

  onModuleInit() {
    //使用 moduleRef 从当前模块中查询 ProductService 资源实例
    this.productService = this.moduleRef.get(ProductService)
  }
}

注入范围

默认情况下，NestJS 容器中创建的资源对象都是单例的。受益于 Node.js 的单进程模型，单例模式在 NestJS 下的使用是非常安全的，不像其他多线程语言对单例的访问操作会存在线程安全问题。因此，在绝大多数情况下，我们的 NestJS 程序在资源创建这块，都推荐使用默认的单例方式。
这种方式，其实也代表了资源的生存范围（Scope）。比如单例的话，是在应用启动后就被初始化，一直到应用关闭。
既然有单例方式，那肯定还有其他方式的存在。NestJS 提供了 3 种范围：
- 单例（SINGLETON）- 默认值，应用一启动就被实例化，只有一个对象实例，在整个应用程序范围内被共享
- 请求（REQUEST）- 针对于每个请求生成一个实例，请求处理结束后销毁
- 零时（TRANSIENT）- 为每个资源消费者生成一个专用实例如果没有特别的原因，建议不要使用 SINGLETON 以外的方式，因为其他两种方式会增加系统消耗，影响到程序的性能。

我们可以在类的 @Injectable 装饰器中指定范围：

//service
import { Injectable, Scope } from '@nestjs/common'

@Injectable({ scope: Scope.REQUEST })
export class MyService {}

也可以在定义资源提供者的地方指定范围：

//module
{
  provide: 'MY_MANAGER',
  useClass: MyManager,
  scope: Scope.TRANSIENT,
}

注意

资源依赖路径上的范围会有层级关系，是一个从底至上的冒泡关系，比如下面这样一个 A 依赖 B，B 依赖 C 的关系中,如果我们指定 BService 的范围为 REQUEST，那么上层的 AService 也会变成 REQUEST 的，而下层的 CService 则仍保持默认的 SINGLETON。

text

AService <- BService <- CService

模块系统

NestJS 框架中，在使用了 JavaScript 模块系统的基础上，又引入了一种特有的模块系统，它只用于管理 NestJS 应用程序中的特定资源内容，声明它们在依赖注入环境下的作用域。
NestJS 中存在容器(module)，容器中存在一个个 NestJS 模块，每个模块拥有控制器(controller)、资源提供者(service)。
每个 NestJS 应用程序其实是由模块组合而成的，它至少需要有一个模块（称为根模块）。多个模块组成一个树状结构。小型应用可能只需要一个根模块就行了，大型应用通常会由大量模块组织而成。

模块的创建

通过在一个普通的类上添加 @Module 装饰器声明来创建。
@Module 装饰器有 4 个配置项，它们的作用分别如下：
1. imports - 需要引入其他模块或者第三方模块，需要将它注册到 imports
2. providers - 属于当前模块的资源提供者
3. controllers - 属于当前模块的路由控制器
4. exports - 模块默认情况对外界访问是封闭的。也就是说，一个模块在未作特别声明的情况下，其内部的资源是不能在两个模块间进行互相依赖注入的，只有本模块内部的资源才能互相注入。如果要支持跨模块注入，需要使用 exports 共享出去。当其他模块导入当前模块后，可访问到的属于当前模块的资源提供者(当前 providers 中的资源)、或由当前模块导入的其他三方模块(当前 import 中的模块)

import { Module } from '@nestjs/common'
import { DemoService } from './demo.service'

@Module({
  imports: [],
  controllers: [],
  providers: [DemoService],
  exports: [DemoService],
})
export class DemoModule {}

模块的分类：功能模块与共享模块

在实际的软件程序中，一定会存在业务类代码和辅助工具类代码。有了模块系统，我们能更好的归类划分不同职责的代码。划分的原则还是以业务和非业务功能为基础，业务上相关联的代码（包括只在该业务中所使用的工具代码）尽量组织在同一个模块中；而和业务无关的、可被其他模块通用的代码，可以按功能分类组织在一个或多个模块之中。

模块的重组

一个模块可以通过 imports 导入其他模块，也可以通过 exports 再次导出这些导入的模块。这样做的目的是：可以实现将各种小粒度的模块排列组合成各种稍大粒度的模块，按照实际需要选择使用稍大粒度的模块，而不是总导入数量较多的小粒度模块。

//此时在另一个模块中导入了当前模块，即会一次性导入三个模块
@Module({
  imports: [HelperAModule, HelperBModule],
  exports: [HelperAModule, HelperBModule],
})
export class HelperModule {}

模块的依赖注入

模块类本身也可以进行依赖注入，让其他资源注入到模块类中。

import { Module } from '@nestjs/common'
import { DemoService } from './demo.service'

@Module({
  imports: [],
  controllers: [],
  providers: [DemoService],
  exports: [DemoService],
})
export class DemoModule {
  constructor(private readonly demoService: DemoService) {
    console.log(demoService)
  }
}

模块的全局化

NestJS 提供了 @Global 装饰器可以将模块（比如数据库连接模块、Redis 缓存模块、一些公用工具模块等）声明成全局作用域。

import { Module, Global } from '@nestjs/common'
import { DemoService } from './demo.service'

//这样一来，需要使用到这个 DemoModule 中资源的其他模块，就不需要通过 imports 来导入它就能使用了。
@Global()
@Module({
  imports: [],
  controllers: [],
  providers: [DemoService],
  exports: [DemoService],
})
export class DemoModule {}

动态模块

通过配置参数的形式来提供具有差异化的功能(如数据库连接模块，接受不同地址连接不同数据库)。

import { Module, DynamicModule } from '@nestjs/common'
import { DemoService } from './demo.service'

@Module({})
export class DemoModule {
  static register(options): DynamicModule {
    // Mockup对象
    const mockDemoService = {
      test() {
        return 'hello,world'
      },
    }

    const definition = {
      module: DemoModule,
      imports: [],
      controllers: [],
      providers: [
        // 根据配置参数中的isDebug值，来决定使用真正的DemoService
        // 作为资源提供者，还是用mockup对象
        options.isDebug
          ? {
              provide: DemoService,
              useValue: mockDemoService,
            }
          : DemoService,
      ],
      exports: [DemoService],
    }

    //类中如果返回对象是引用类型，实例化时会将该对象赋值给实例对象
    return definition
  }
}

//之后通过类静态方法来传参
import { Module } from '@nestjs/common'
import { AppController } from './app.controller'
import { AppService } from './app.service'
import { DemoModule } from './demo.module'

@Module({
  // 调用模块中的静态方法获取动态模块
  imports: [DemoModule.register({ isDebug: false })],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

DTO

数据访问对象简称 DTO（Data Transfer Object），是一组需要跨进程或网络边界传输的聚合数据的简单容器。它不应该包含业务逻辑，并将其行为限制为诸如内部一致性检查和基本验证之类的活动。
在 Nestjs 中，可以使用 TypeScript 接口或简单的类来完成。配合 class-validator 和 class-transformer 可以很方便地验证前端传过来的参数
DTO 中的 class-validator 还需要配合 pipe 才能完成校验功能

//service.ts
import { IsString, IsInt, MinLength, MaxLength } from 'class-validator'
import { ApiModelProperty } from '@nestjs/swagger'

export class CreateCatDto {
  @ApiModelProperty()
  @IsString()
  @MinLength(10, {
    message: 'Name is too short',
  })
  @MaxLength(50, {
    message: 'Name is too long',
  })
  readonly name: string

  @ApiModelProperty()
  @IsInt()
  readonly age: number

  @ApiModelProperty()
  @IsString()
  readonly breed: string
}

//controller.ts,如果 Body 中的参数不符合要求，会直接报 Validation failed 错误。
import { Controller, Post, Body } from '@nestjs/common'
import { CreateCatDto } from './dto'

@Controller('cats')
export class CatsController {
  @Post()
  create(@Body() createCatDto: CreateCatDto) {
    return 'This action adds a new cat'
  }
}

ORM

ORM 是 "对象 - 关系映射"（Object/Relational Mapping）的缩写，通过实例对象的语法，完成关系型数据库的操作。通过 ORM 就可以用面向对象编程的方式去操作关系型数据库。在 Java 中，通常会有 DAO（Data Access Object，数据访问对象）层，DAO 中包含了各种数据库的操作方法。通过它的方法，对数据库进行相关的操作。DAO 主要作用是分离业务层与数据层，避免业务层与数据层耦合。在 Nestjs 中，可以用 TypeORM 作为你的 DAO 层，它支持 MySQL / MariaDB / PostgreSql / CockroachDB / SQLite / Microsoft SQL Server / Oracle / MongoDB / NoSQL。在 service 调用 DAO （在 Nestjs 中是各种 ORM 工具或者自己封装的 DAO 层）实现数据库的访问，进行数据的处理整合。在 typeORM 中数据库的表对应的就是一个类，通过定义一个类来创建实体。实体（Entity）是一个映射到数据库表（或使用 MongoDB 时的集合）的类，通过 @Entity() 来标记。

import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm'

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

  @Column()
  firstName: string

  @Column()
  lastName: string

  @Column()
  age: number
}

text

上面代码将创建以下数据库表：
+-------------+--------------+----------------------------+
|                          user                           |
+-------------+--------------+----------------------------+
| id          | int(11)      | PRIMARY KEY AUTO_INCREMENT |
| firstName   | varchar(255) |                            |
| lastName    | varchar(255) |                            |
| isActive    | boolean      |                            |
+-------------+--------------+----------------------------+

使用 @InjectRepository() 修饰器注入对应的 Repository，就可以在这个 Repository 对象上进行数据库的一些操作。

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 readonly userRepository: Repository<User>
  ) {}

  async findAll(): Promise<User[]> {
    return await this.userRepository.find()
  }
}

::: right 参考一斤代码
参考 tc9011 :::

如果你也喜欢前端

欢迎加入QQ交流群 🎉🎉🎉

路由与控制器

路由路径匹配规则

标准模式和特定库模式

其他常用装饰器的功能

@Param - 路径动态参数装饰器

@Post + @Body - 获取 POST 请求的请求体

@Headers 和 @Header - 获取请求头和设置响应头

面向切面编程

Middlewares(中间件)

Guards(守卫)

Interceptors(拦截器)

Pipes(管道)

Exception filters(异常处理)

利用 AOP 的思想使用 Interceptor 和 Exception Filter 去处理全局错误

NestJS 中依赖注入

Nest 中一个容器注入的例子

资源提供者

一、使用类作为提供者，称为 ClassProvider

二、使用常量值（可以是简单基础类型值，也可以是对象），称为 ValueProvider

三、使用工厂函数，称为 FactoryProvider

四、用于给其他已有的资源提供者创建其他别名的方式，称为 ExistingProvider

资源注入方式

依赖注入边界

异步资源提供者

循环依赖问题与解决方式

注入范围

模块系统

模块的创建

模块的分类：功能模块与共享模块

模块的重组

模块的依赖注入

模块的全局化

动态模块

DTO

ORM

如果你也喜欢前端

欢迎加入QQ交流群 🎉🎉🎉

路由与控制器 ​

路由路径匹配规则 ​

标准模式和特定库模式 ​

其他常用装饰器的功能 ​

@Param - 路径动态参数装饰器 ​

@Post + @Body - 获取 POST 请求的请求体 ​

@Headers 和 @Header - 获取请求头和设置响应头 ​

面向切面编程 ​

Middlewares(中间件) ​

Guards(守卫) ​

Interceptors(拦截器) ​

Pipes(管道) ​

Exception filters(异常处理) ​

利用 AOP 的思想使用 Interceptor 和 Exception Filter 去处理全局错误 ​

NestJS 中依赖注入 ​

Nest 中一个容器注入的例子 ​

资源提供者 ​

一、使用类作为提供者，称为 ClassProvider ​

二、使用常量值（可以是简单基础类型值，也可以是对象），称为 ValueProvider ​

三、使用工厂函数，称为 FactoryProvider ​

四、用于给其他已有的资源提供者创建其他别名的方式，称为 ExistingProvider ​

资源注入方式 ​

依赖注入边界 ​

异步资源提供者 ​

循环依赖问题与解决方式 ​

注入范围 ​

模块系统 ​

模块的创建 ​

模块的分类：功能模块与共享模块 ​

模块的重组 ​

模块的依赖注入 ​

模块的全局化 ​

动态模块 ​

DTO ​

ORM ​

路由与控制器

路由路径匹配规则

标准模式和特定库模式

其他常用装饰器的功能

@Param - 路径动态参数装饰器

@Post + @Body - 获取 POST 请求的请求体

@Headers 和 @Header - 获取请求头和设置响应头

面向切面编程

Middlewares(中间件)

Guards(守卫)

Interceptors(拦截器)

Pipes(管道)

Exception filters(异常处理)

利用 AOP 的思想使用 Interceptor 和 Exception Filter 去处理全局错误

NestJS 中依赖注入

Nest 中一个容器注入的例子

资源提供者

一、使用类作为提供者，称为 ClassProvider

二、使用常量值（可以是简单基础类型值，也可以是对象），称为 ValueProvider

三、使用工厂函数，称为 FactoryProvider

四、用于给其他已有的资源提供者创建其他别名的方式，称为 ExistingProvider

资源注入方式

依赖注入边界

异步资源提供者

循环依赖问题与解决方式

注入范围

模块系统

模块的创建

模块的分类：功能模块与共享模块

模块的重组

模块的依赖注入

模块的全局化

动态模块

DTO

ORM