1.8 providers

1. 生成providers

nest g service <name>

2. providers的注入方式

构造函数注入

@Injectable()
export class KeywordService {
  constructor(
    private readonly httpService: HttpService,
    private readonly pro: ProService,
  ) {}
}

@Inject()注入

export class KeywordController {
  @Inject()
  private readonly httpService: HttpService;
  @Inject()
  private readonly keywordService: KeywordService;
}

3. providers注册

@Module({
  imports: [
    HttpModule.register({
      timeout: 5000,
      maxRedirects: 5,
      baseURL: 'http://localhost:3000',
    }),
    ProModule,
  ],
  controllers: [KeywordController],
  providers: [KeywordService],
})
export class KeywordModule {}

4. 创建providers

a. 使用@Injectable()注解

b. providers完整写法

在module中注册时，一般使用简写，下面是providers的完整写法

providers: [
  {
    provide: CatsService,
    useClass: CatsService,
  },
];

c. 值提供者/value providers

//mock.ts
export class Mock {
  getHello(): string {
    return 'hello world';
  }
}

//pro.module.ts
@Module({
  providers: [
    {
      provide: ProService,
      useValue: new Mock(),
    },
  ],
  exports: [ProService],
})

//Mock类要和ProService类拥有同样的方法，即Mock和ProService都有一个getHello()方法，则nest在解析时，会用Mock的getHello()方法替换掉ProService的getHello()方法

d. 非类提供者/Non-class-based provider tokens

//pro.module.ts
import { Mock } from './mock';
@Module({
  providers: [
    {
      provide: 'connect',
      useValue: new Mock(),
    },
  ],
  exports: ['connect'],
})
export class ProModule {}
//mock.ts
export class Mock {
  getHello(): string {
    return 'hello world';
  }
}

//注入
import { Mock } from '../pro/mock';
@Controller('keyword')
export class KeywordController {
@Inject('connect')
  private readonly mock: Mock;
}

e. 类提供者/useClass

import { ProService } from './pro.service';
@Module({
  providers: [
    {
      provide: 'ProService',
      useClass: ProService,
    },
  ],
  exports: ['ProService'],
})
export class ProModule {}

或者用三元操作符来判断，返回特定的提供者

import { Module } from '@nestjs/common';
import { ProService } from './pro.service';
import { FactoryService } from './factory.service';

let a;

@Module({
  providers: [
    {
      provide: 'CONNECTION',
      useClass: a ? ProService : FactoryService,
    },
  ],
  exports: ['CONNECTION'],
})
export class ProModule {}

f. 工厂提供者/factory providers

import { Module } from '@nestjs/common';
import { FactoryService } from './factory.service';


@Module({
  providers: [
    FactoryService, //必须引入，或者直接引入FactoryModule
    {
      provide: 'CONNECTION',
      useFactory: (fac: FactoryService) => {
        return String(fac.getHello());
      },
      inject: [FactoryService],
    },
  ],
  exports: ['CONNECTION'],
})
export class ProModule {}

或者

@Module({
  imports: [FactoryModule],
  providers: [
    {
      provide: 'CONNECTION',
      useFactory: (fac: FactoryService) => {
        return String(fac.getHello());
      },
      inject: [FactoryService],
    },
  ],
  exports: ['CONNECTION'],
})

或者

import { Module } from '@nestjs/common';
import { FactoryService } from './factory.service';
import { FactoryModule } from './factory.module';
const connectionFactory = {
  provide: 'CONNECTION',
  useFactory: (optionsProvider: FactoryService) => {
    const options = optionsProvider.getHello();
    return String(options);
  },
  inject: [FactoryService],
};

@Module({
  imports: [FactoryModule],
  providers: [connectionFactory, FactoryService],
  exports: [connectionFactory],
})

或者直接提供值

import { Module } from '@nestjs/common';
import { FactoryService } from './factory.service';
import { FactoryModule } from './factory.module';
const config = {
  data: {
    a: 1,
    b: 2,
  },
};
const connectionFactory = {
  provide: 'CONNECTION',
  useFactory: () => config,
};

@Module({
  imports: [FactoryModule],
  providers: [connectionFactory, FactoryService],
  exports: [connectionFactory],
})

g.别名提供者

import { Module } from '@nestjs/common';
import { FactoryService } from './factory.service';
import { FactoryModule } from './factory.module';

const TestService = {
  provide: 'Test',
  useExisting: FactoryService,
};
//TestService和FactoryService是同一个提供者
@Module({
  imports: [FactoryModule],
  providers: [FactoryService, TestService],
  exports: [TestService, FactoryService],
})

h.导出提供者

//可以导出令牌，也可以导出整个对象
exports: [‘Test', FactoryService]

i. 异步提供者

//在实例化依赖于(注入)这样一个提供程序的任何类之前，Nest将等待承诺的解决
{
  provide: 'ASYNC_CONNECTION',
  useFactory: async () => {
    const connection = await createConnection(options);
    return connection;
  },
}