提供者

在模块中使用 providers 声明提供者，提供者需要被注册到模块的服务容器中，才可被依赖注入。

• 提供者使用 @Injectable() 装饰器定义，这样系统会分析 constructor 进行依赖注入
• 提供者在模块的 providers 属性中定义，用于注册到服务容器中，用于被其他类依赖注入
• 提供者可以在自身的constructor构造函数中依赖注入其他服务提供者，需要使用 @Injectable() 装饰器声明该提供者
• 注册到容器的提供者，默认只对当前模块有效，即作用域为模块
• 可以使用 exports 导出给其他模块使用
• 提供者是单例的
• 提供者可以是任何值，而不仅仅是服务类

提供者在模块的providers属性中声明，我们有多种将提供者注册到容器的方法，下面来学习使用。

基本数据

我们也可以将普通数据使用 useValue 注册到服务容器

@Module({
  providers: [{
    provide: 'APP_NAME',
    useValue: '斑马兽-何俊',
  }],
})

因为普通数据服务不是class，所以要使用**@Inject**进行注入

@Injectable()
export class AuthService {
  constructor(
    @Inject('APP_NAME')
    private appName,
  ) {}
  show() {
    return this.appName
  }
  ...
}

类注册

使用类将提供者注册到服务容器是最常用的方式。

基本使用

下面是常用的使用类将提供者注册到容器的方式

@Module({
  providers: [AuthService],
})

以上是简写形式，完整写法应该如下

@Module({
  providers: [{
    provide: AuthService,
    useClass: AuthService,
  }],
})

动态注册

下面实现根据不同的环境创建不同的服务，首先安装 dotenv 扩展包，用来读取**.env**环境变量。

pnpm add dotenv

然后创建两个服务 app.service.ts 与 bm.service.ts

appService.ts 内容

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

@Injectable()
export class AppService {
  getHello(): string {
    return 'app getHello';
  }
}

bm.service.ts 内容

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

@Injectable()
export class BmService {
  getHello(): string {
    return 'bm getHello';
  }
}

然后在模块中根据环境变量动态设置服务

import { Module } from '@nestjs/common';
import { config } from 'dotenv';
import path from 'path';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { BmService } from './bm.service';

//读取.env 到 process.env 环境变量中
config({ path: path.join(__dirname, '../.env') });

const appService = {
  provide: AppService,
  useClass: process.env.NODE_ENV === 'development' ? AppService : BmService,
};

@Module({
  imports: [],
  controllers: [AppController],
  providers: [appService],
})
export class AppModule {}

工厂函数

针对于复杂要求的provider ，我们可以使用 useFactory 工厂函数对提供者进行注册。

基本使用

下面使用工厂函数注册基本数据

import { Module } from '@nestjs/common'
import { AuthController } from './auth.controller'
import { AuthService } from './auth.service'

class HjClass {
  make() {
    return 'this is HjClass Make Method'
  }
}
@Module({
  providers: [
    AuthService,
    HjClass,
    {
      provide: 'BM',
      //依赖注入其他提供者,将做为参数传递给 useFactory 方法
      inject: [HjClass],
      useFactory: (hjClass) => {
        return hjClass.make()
      },
    },
  ],
  controllers: [AuthController],
})
export class AuthModule {}

在其他服务中使用定义的BM提供者

@Injectable()
export class AuthService {
  constructor(
    @Inject('BM')
    private bm
  ) {}
  show() {
    return this.bm
  }
  ...
}

动态配置

下面使用工厂函数实现根据.env 环境变量值，加载不同配置项。

首先创建config/development.config.ts 与config/production.config.ts 配置文件

development.config.ts

export const devConfig = {
  url: 'localhost',
};

production.config.ts

export const productionConfig = {
  url: 'banmashou.com',
};

然后在模块中使用 useFactory 动态注册配置

import { Module } from '@nestjs/common';
import { config } from 'dotenv';
import path from 'path';
import { AppController } from './app.controller';
import { devConfig } from './config/development.config';
import { productionConfig } from './config/production.config';
config({ path: path.join(__dirname, '../.env') });

const configService = {
  provide: 'config',
  useFactory() {
    return process.env.NODE_ENV === 'development'
      ? devConfig
      : productionConfig;
  },
};
@Module({
  imports: [],
  controllers: [AppController],
  providers: [appService, configService],
})
export class AppModule {}

服务导出

默认情况下服务只在当前模块有效，如果服务要供其他模块使用，需要在该服务所在模块的 exports 属性中声明导出。

导出服务

下例是将 hj.module.ts 模块的服务 HjService 导出给其他模块使用。

import { Module } from '@nestjs/common';
import { HjService } from './hj.service';
import { HjController } from './hj.controller';

@Module({
  providers: [HjService],
  controllers: [HjController],
  exports: [HjService],
})
export class HjModule {}

导入服务

其他模块需要imports导入该模块后,才可以使用该模块导出的服务，下面是 BmModule 模块使用 HjModule 的 HjService 服务的定义。

import { HjModule } from './../hj/hj.module';
import { Module } from '@nestjs/common';
import { BmController } from './bm.controller';
import { BmService } from './bm.service';

@Module({
  imports: [HjModule],
  controllers: [BmController],
  providers: [BmService],
})
export class BmModule {}

异步提供者

我们也可以注册异步提供者，用于对异步业务的处理。

声明导出

下面在 BmModule 模块中定义异步提供者 HjAsyncService

import { Module } from '@nestjs/common';
import { BmController } from './bm.controller';
import { BmService } from './bm.service';

@Module({
  imports: [],
  controllers: [BmController],
  providers: [
    BmService,
    {
      provide: 'BmAsyncService',
      useFactory: async () => {
        return new Promise((r) => {
          setTimeout(() => {
            r('何俊');
          }, 3000);
        });
      },
    },
  ],
  exports: [BmService, 'BmAsyncService'],
})
export class BmModule {}

使用提供者

然后在 HjModule 中使用 BmModule 模块导出的 BmAsyncService

import { Module } from '@nestjs/common';
import { BmModule } from './../bm/bm.module';
import { HjController } from './hj.controller';
import { HjService } from './hj.service';

@Module({
  imports: [BmModule],
  providers: [HjService],
  controllers: [HjController],
  exports: [HjService],
})
export class HjModule {}

现在就可以在 HjModule 模块的控制器中使用 BmAsyncService 服务了

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

@Controller('hj')
export class HjController {
  constructor(
    @Inject('HjAsyncService')
    private readonly hjAsyncService: string,
  ) {}
  @Get()
  show() {
    return this.hjAsyncService;
  }
}