Nest.js系列之Providers及模块功能怎么使用

目录

1. 引言
2. Providers 简介
3. 创建自定义 Provider
4. Provider 的作用域
5. 模块功能简介
6. 模块的组织与依赖
7. 共享模块
8. 全局模块
9. 动态模块
10. 总结

引言

Nest.js 是一个用于构建高效、可扩展的 Node.js 服务器端应用程序的框架。它采用了模块化的架构，使得开发者可以轻松地组织和管理代码。在 Nest.js 中，Providers 和模块功能是两个非常重要的概念。本文将详细介绍如何在 Nest.js 中使用 Providers 和模块功能，帮助你更好地理解和应用这些概念。

Providers 简介

在 Nest.js 中，Providers 是一个非常重要的概念。它们可以是服务、存储库、工厂、助手等任何可以被注入到其他类中的对象。Providers 的主要作用是将逻辑封装在一个独立的类中，以便在其他地方重用。

什么是 Provider？

Provider 是一个普通的 JavaScript 类，通常使用 @Injectable() 装饰器进行标记。这个装饰器告诉 Nest.js 这个类可以被注入到其他类中。

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

@Injectable()
export class CatsService {
  private readonly cats: string[] = [];

  findAll(): string[] {
    return this.cats;
  }

  create(cat: string) {
    this.cats.push(cat);
  }
}

在上面的例子中，CatsService 是一个 Provider。它被标记为 @Injectable()，因此可以被注入到其他类中。

如何使用 Provider？

要在其他类中使用 Provider，你需要将其注入到目标类的构造函数中。Nest.js 会自动处理依赖注入的过程。

import { Controller, Get, Post, Body } from '@nestjs/common';
import { CatsService } from './cats.service';

@Controller('cats')
export class CatsController {
  constructor(private readonly catsService: CatsService) {}

  @Get()
  findAll(): string[] {
    return this.catsService.findAll();
  }

  @Post()
  create(@Body('name') name: string) {
    this.catsService.create(name);
  }
}

在上面的例子中，CatsController 通过构造函数注入了 CatsService。这样，CatsController 就可以使用 CatsService 提供的方法了。

创建自定义 Provider

除了使用 @Injectable() 装饰器创建 Provider 外，Nest.js 还提供了其他方式来创建自定义 Provider。

使用 useValue

useValue 允许你直接提供一个值作为 Provider。这在需要注入常量或模拟对象时非常有用。

const mockCatsService = {
  findAll: () => ['mock cat'],
};

@Module({
  providers: [
    {
      provide: CatsService,
      useValue: mockCatsService,
    },
  ],
})
export class AppModule {}

在上面的例子中，CatsService 被替换为一个模拟对象 mockCatsService。

使用 useClass

useClass 允许你动态地指定一个类作为 Provider。这在需要根据条件选择不同的实现时非常有用。

class ConfigService {}

class DevelopmentConfigService extends ConfigService {}

class ProductionConfigService extends ConfigService {}

@Module({
  providers: [
    {
      provide: ConfigService,
      useClass:
        process.env.NODE_ENV === 'development'
          ? DevelopmentConfigService
          : ProductionConfigService,
    },
  ],
})
export class AppModule {}

在上面的例子中，ConfigService 的实现会根据环境变量 NODE_ENV 的值动态选择。

使用 useFactory

useFactory 允许你使用工厂函数来创建 Provider。这在需要根据其他 Provider 或配置来动态创建对象时非常有用。

@Module({
  providers: [
    {
      provide: 'CONNECTION',
      useFactory: (optionsProvider: OptionsProvider) => {
        const options = optionsProvider.get();
        return new DatabaseConnection(options);
      },
      inject: [OptionsProvider],
    },
  ],
})
export class AppModule {}

在上面的例子中，CONNECTION Provider 是通过工厂函数创建的，并且依赖于 OptionsProvider。

Provider 的作用域

在 Nest.js 中，Provider 的作用域决定了它的生命周期。默认情况下，Provider 是单例的，即在整个应用程序中只有一个实例。然而，Nest.js 也支持其他作用域。

默认作用域

默认情况下，Provider 是单例的。这意味着在整个应用程序中，同一个 Provider 只会被实例化一次。

@Injectable()
export class CatsService {
  constructor() {
    console.log('CatsService instantiated');
  }
}

在上面的例子中，CatsService 只会被实例化一次，无论它被注入到多少个类中。

请求作用域

请求作用域的 Provider 会在每个请求中创建一个新的实例。这对于需要在每个请求中保持独立状态的 Provider 非常有用。

@Injectable({ scope: Scope.REQUEST })
export class CatsService {
  constructor() {
    console.log('CatsService instantiated');
  }
}

在上面的例子中，CatsService 会在每个请求中创建一个新的实例。

瞬态作用域

瞬态作用域的 Provider 会在每次注入时创建一个新的实例。这对于需要在每次注入时保持独立状态的 Provider 非常有用。

@Injectable({ scope: Scope.TRANSIENT })
export class CatsService {
  constructor() {
    console.log('CatsService instantiated');
  }
}

在上面的例子中，CatsService 会在每次注入时创建一个新的实例。

模块功能简介

在 Nest.js 中，模块是组织应用程序的基本单元。每个模块都包含了一组相关的功能，如控制器、Provider 等。模块可以帮助你将应用程序分解为更小、更易于管理的部分。

什么是模块？

模块是一个使用 @Module() 装饰器标记的类。这个装饰器接受一个对象，用于配置模块的元数据。

import { Module } from '@nestjs/common';
import { CatsController } from './cats.controller';
import { CatsService } from './cats.service';

@Module({
  controllers: [CatsController],
  providers: [CatsService],
})
export class CatsModule {}

在上面的例子中，CatsModule 是一个模块。它包含了 CatsController 和 CatsService。

模块的元数据

@Module() 装饰器接受一个对象，该对象包含以下属性：

• controllers: 该模块中使用的控制器。
• providers: 该模块中使用的 Provider。
• imports: 该模块依赖的其他模块。
• exports: 该模块导出的 Provider，其他模块可以导入并使用这些 Provider。

模块的组织与依赖

在大型应用程序中，通常会有多个模块。为了保持代码的组织性和可维护性，你需要合理地组织模块，并管理它们之间的依赖关系。

模块的组织

通常，你可以根据功能将应用程序分解为多个模块。例如，你可以创建一个 UsersModule 来处理用户相关的功能，创建一个 ProductsModule 来处理产品相关的功能。

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

@Module({
  controllers: [ProductsController],
  providers: [ProductsService],
})
export class ProductsModule {}

在上面的例子中，UsersModule 和 ProductsModule 分别处理用户和产品相关的功能。

模块的依赖

模块之间可以通过 imports 属性建立依赖关系。例如，如果 ProductsModule 需要使用 UsersModule 中的 Provider，你可以在 ProductsModule 中导入 UsersModule。

@Module({
  imports: [UsersModule],
  controllers: [ProductsController],
  providers: [ProductsService],
})
export class ProductsModule {}

在上面的例子中，ProductsModule 导入了 UsersModule，因此可以使用 UsersModule 中导出的 Provider。

共享模块

在 Nest.js 中，模块可以通过 exports 属性导出 Provider，以便其他模块可以使用这些 Provider。

导出 Provider

要导出 Provider，你需要在模块的 exports 属性中列出这些 Provider。

@Module({
  providers: [CatsService],
  exports: [CatsService],
})
export class CatsModule {}

在上面的例子中，CatsModule 导出了 CatsService，因此其他模块可以导入 CatsModule 并使用 CatsService。

导入共享模块

要使用其他模块导出的 Provider，你需要在目标模块的 imports 属性中导入该模块。

@Module({
  imports: [CatsModule],
  controllers: [DogsController],
  providers: [DogsService],
})
export class DogsModule {}

在上面的例子中，DogsModule 导入了 CatsModule，因此可以使用 CatsModule 中导出的 CatsService。

全局模块

在某些情况下，你可能希望某些模块在整个应用程序中全局可用，而不需要在每个模块中显式导入。Nest.js 提供了全局模块的功能来实现这一点。

创建全局模块

要创建全局模块，你需要在模块的 @Module() 装饰器中使用 global: true 选项。

@Module({
  providers: [CatsService],
  exports: [CatsService],
  global: true,
})
export class CatsModule {}

在上面的例子中，CatsModule 被标记为全局模块，因此可以在整个应用程序中使用 CatsService，而不需要在每个模块中显式导入 CatsModule。

使用全局模块

全局模块的 Provider 可以在任何模块中使用，而不需要显式导入。

@Module({
  controllers: [DogsController],
  providers: [DogsService],
})
export class DogsModule {
  constructor(private readonly catsService: CatsService) {}
}

在上面的例子中，DogsModule 可以直接使用 CatsService，而不需要显式导入 CatsModule。

动态模块

动态模块允许你在运行时动态地配置模块。这对于需要根据配置或环境变量来调整模块行为的场景非常有用。

创建动态模块

要创建动态模块，你需要在模块类中定义一个静态方法 forRoot() 或 forFeature()，并在该方法中返回一个动态配置的模块。

@Module({})
export class DatabaseModule {
  static forRoot(options: DatabaseOptions): DynamicModule {
    return {
      module: DatabaseModule,
      providers: [
        {
          provide: 'DATABASE_OPTIONS',
          useValue: options,
        },
        DatabaseService,
      ],
      exports: [DatabaseService],
    };
  }
}

在上面的例子中，DatabaseModule 提供了一个 forRoot() 方法，允许在导入模块时传递配置选项。

使用动态模块

要使用动态模块，你需要在导入模块时调用 forRoot() 方法，并传递配置选项。

@Module({
  imports: [DatabaseModule.forRoot({ host: 'localhost', port: 5432 })],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

在上面的例子中，AppModule 导入了 DatabaseModule，并传递了数据库连接的配置选项。

总结

在 Nest.js 中，Providers 和模块功能是两个非常重要的概念。通过合理地使用 Providers 和模块功能，你可以轻松地组织和管理代码，构建高效、可扩展的应用程序。本文详细介绍了如何在 Nest.js 中使用 Providers 和模块功能，包括创建自定义 Provider、管理 Provider 的作用域、组织模块、共享模块、全局模块和动态模块。希望这些内容能帮助你更好地理解和应用 Nest.js 中的这些概念。