如何在NestJs中基于运行时动态条件创建与注入服务

NestJS的DI系统完全支持运行时动态选择、按需加载服务，下面给你几种实用的解决办法：

方案一：使用ModuleRef动态获取服务实例 #

核心是利用Nest提供的ModuleRef类，它允许你在运行时从DI容器中获取服务实例，不需要提前在构造函数中注入所有可能用到的服务。而且Nest的单例服务默认是首次被获取时才实例化，刚好实现按需加载的效果。

代码示例 #

首先定义接口和服务：

export interface ServiceInterface {
  doStuff(): void;
}

@Injectable()
export class AService implements ServiceInterface {
  doStuff() {
    console.log('AService执行任务');
  }
}

@Injectable()
export class BService implements ServiceInterface {
  doStuff() {
    console.log('BService执行任务');
  }
}

然后在业务服务中注入ModuleRef，动态获取目标服务：

@Injectable()
export class RunningService {
  constructor(private readonly moduleRef: ModuleRef) {}

  async runningMethod() {
    const condition = this.getRuntimeCondition(); // 你的运行时条件逻辑
    let chosenService: ServiceInterface;

    switch (condition) {
      case 'A':
        // 首次调用时才会实例化AService
        chosenService = this.moduleRef.get(AService);
        break;
      case 'B':
        chosenService = this.moduleRef.get(BService);
        break;
      // 其他条件分支...
    }

    chosenService?.doStuff();
  }

  private getRuntimeCondition(): string {
    // 模拟运行时动态生成的条件
    return Math.random() > 0.5 ? 'A' : 'B';
  }
}

注意：如果需要每次获取新实例（而非单例），可以使用moduleRef.create(AService)，效果类似Java中直接new对象。

方案二：封装服务工厂统一管理 #

如果需要更灵活的服务选择逻辑，可以封装一个专门的服务工厂，把服务映射和选择逻辑集中起来，避免业务代码中充斥大量switch分支：

代码示例 #

先实现服务工厂：

@Injectable()
export class ServiceFactory {
  constructor(private readonly moduleRef: ModuleRef) {}

  getService(condition: string): ServiceInterface {
    // 维护服务与条件的映射关系
    const serviceMap: Record<string, Type<ServiceInterface>> = {
      'A': AService,
      'B': BService,
      // 新增服务只需在这里添加映射
    };

    const ServiceClass = serviceMap[condition];
    if (!ServiceClass) {
      throw new Error(`未找到匹配条件${condition}的服务`);
    }

    return this.moduleRef.get(ServiceClass);
  }
}

然后在业务服务中使用工厂：

@Injectable()
export class RunningService {
  constructor(private readonly serviceFactory: ServiceFactory) {}

  async runningMethod() {
    const condition = this.getRuntimeCondition();
    const chosenService = this.serviceFactory.getService(condition);
    chosenService.doStuff();
  }

  private getRuntimeCondition(): string {
    return Math.random() > 0.5 ? 'A' : 'B';
  }
}

这种方式扩展性更强，新增服务时不需要修改业务代码，只需要更新工厂内的映射表即可。

方案三：延迟加载整个模块（适合服务量大的场景） #

如果你的服务分散在不同模块中，且希望整个模块（包括其依赖）都按需加载，可以使用Nest的延迟加载模块功能，进一步减少启动时的资源占用。

代码示例 #

先定义独立的服务模块：

@Module({
  providers: [AService],
  exports: [AService],
})
export class AModule {}

然后在业务服务中动态导入模块并获取服务：

@Injectable()
export class RunningService {
  constructor(private readonly moduleRef: ModuleRef) {}

  async runningMethod() {
    const condition = this.getRuntimeCondition();
    let chosenService: ServiceInterface;

    if (condition === 'A') {
      // 首次使用时才会加载AModule并初始化AService
      const { AModule } = await import('./a.module');
      const moduleRef = await this.moduleRef.create(AModule);
      chosenService = moduleRef.get(AService);
    } else if (condition === 'B') {
      const { BModule } = await import('./b.module');
      const moduleRef = await this.moduleRef.create(BModule);
      chosenService = moduleRef.get(BService);
    }

    chosenService?.doStuff();
  }

  private getRuntimeCondition(): string {
    return Math.random() > 0.5 ? 'A' : 'B';
  }
}

这种方式适合服务数量多、模块依赖复杂的场景，能有效降低程序启动时间和内存占用。

内容的提问来源于stack exchange，提问作者Felix