生成providers
nest g service <name>
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;
}
providers注册
@Module({
imports: [
HttpModule.register({
timeout: 5000,
maxRedirects: 5,
baseURL: 'http://localhost:3000',
}),
ProModule,
],
controllers: [KeywordController],
providers: [KeywordService],
})
export class KeywordModule {}
创建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;
},
}