2.1 循环依赖

1. provider

两个provider中必须同时有forwardRef正向引用

import { forwardRef, Inject, Injectable } from '@nestjs/common';
import { ProService } from '../pro/pro.service';

@Injectable()
export class FactoryService {
  @Inject(forwardRef(() => ProService))
  private readonly proService: ProService;
  getHello(): string {
    return 'this.proService.getHello()';
  }
}

import { forwardRef, Inject, Injectable } from '@nestjs/common';
import { FactoryService } from '../global/factory.service';

@Injectable()
export class ProService {
  @Inject(forwardRef(() => FactoryService))
  private readonly factory: FactoryService;
  getHello(): string {
    return this.factory.getHello();
  }
}

2. module

a.静态模块，且provider和controller非范围提供者/控制器

factory.service.ts

import { Injectable, OnModuleInit } from '@nestjs/common';
import { ModuleRef } from '@nestjs/core';
import { ProService } from '../pro/pro.service';
import { FactoryController } from './factory.controller';
import { ProController } from '../pro/pro.controller';

@Injectable()
export class FactoryService implements OnModuleInit {
  private service: FactoryService;
  private pro: ProService;
  private con: ProController;
  private config;
  constructor(private moduleRef: ModuleRef) {}

  getHello(): string {
    return this.config;
  }
  get(): string {
    return 'hello test';
  }
  onModuleInit(): any {
    this.service = this.moduleRef.get(FactoryService);   //获取本模块的提供者
    this.pro = this.moduleRef.get(ProService, { strict: false }); //获取循环依赖的模块的提供者
    this.con = this.moduleRef.get(ProController, { strict: false });//获取循环依赖的模块的控制器
    this.config = this.moduleRef.get('config', { strict: false });//通过令牌获取提供者
  }
}

factory.module.ts

import { forwardRef, Module } from '@nestjs/common';
import { FactoryService } from './factory.service';
import { ProModule } from '../pro/pro.module';
import { FactoryController } from './factory.controller';
@Module({
  imports: [forwardRef(() => ProModule)],
  providers: [FactoryService],
  controllers: [FactoryController],
  exports: [FactoryService],
})
export class FactoryModule {}

pro.module.ts

import { forwardRef, Module } from '@nestjs/common';
import { ProService } from './pro.service';
import { FactoryModule } from '../global/factory.module';
import { ProController } from './pro.controller';

@Module({
  imports: [forwardRef(() => FactoryModule)],
  controllers: [ProController],
  providers: [
    {
      provide: 'config',
      useValue: 'options',
    },
    ProService,
  ],
  exports: ['config', ProService],
})
export class ProModule {}

注：静态模块中的循环依赖经测试没有问题，如果是动态模块的话，则不能处理循环依赖问题

b. 静态模块间循环依赖，且provider和controller为范围提供者/控制器

 async onModuleInit() {
    this.transientService = await this.moduleRef.resolve(TransientService);
  }