NestJS：如何多次导入动态模块

你可以通过改进QueuesModule的动态配置，支持自定义注入令牌，结合子模块封装每个队列的配置，实现优雅的多队列注入。以下是具体步骤：

1. 改进QueuesModule，支持自定义令牌 #

修改QueuesModule的forRoot方法，允许传入队列标识（令牌），并基于该令牌创建独立的QueuesService实例：

import { DynamicModule, InjectionToken, Module } from '@nestjs/common';
import { QueuesService } from './queues.service';
import { QueuesRepository } from './queues.repository';
import { defaultRepository } from './default-repo';

@Module({
  providers: [
    QueuesRepository,
    { provide: 'SQSClient', useValue: defaultRepository },
  ],
})
export class QueuesModule {
  static forRoot(options: { endpoint: string; token: InjectionToken }): DynamicModule {
    // 创建绑定到自定义令牌的QueuesService实例
    const queueServiceProvider = {
      provide: options.token,
      useFactory: (repo: QueuesRepository, client: typeof defaultRepository) => {
        return new QueuesService(repo, client, options.endpoint);
      },
      inject: [QueuesRepository, 'SQSClient'],
    };

    return {
      module: QueuesModule,
      providers: [queueServiceProvider],
      exports: [queueServiceProvider], // 导出当前令牌对应的服务实例
    };
  }
}

确保QueuesService的构造函数能接收端点参数：

import { Injectable, Inject } from '@nestjs/common';
import { QueuesRepository } from './queues.repository';

@Injectable()
export class QueuesService {
  constructor(
    private readonly repo: QueuesRepository,
    @Inject('SQSClient') private readonly client: any,
    private readonly endpoint: string
  ) {}

  // 队列相关业务方法...
}

2. 为每个队列封装专属模块 #

创建独立的队列模块，封装对应队列的配置和令牌，方便其他模块导入：

import { Module } from '@nestjs/common';
import { QueuesModule } from './queues.module';

@Module({
  imports: [
    QueuesModule.forRoot({
      endpoint: 'http://foo.queue/',
      token: 'FooQueueService',
    }),
  ],
  exports: ['FooQueueService'], // 导出当前队列的服务令牌
})
export class FooQueueModule {}

@Module({
  imports: [
    QueuesModule.forRoot({
      endpoint: 'http://bar.queue/',
      token: 'BarQueueService',
    }),
  ],
  exports: ['BarQueueService'],
})
export class BarQueueModule {}

3. 在业务模块中导入并注入多队列 #

在需要使用多队列的模块中，导入所有队列专属模块，然后通过@Inject()装饰器注入对应实例：

import { Module } from '@nestjs/common';
import { FooQueueModule } from './foo-queue.module';
import { BarQueueModule } from './bar-queue.module';
import { BusinessService } from './business.service';

@Module({
  imports: [FooQueueModule, BarQueueModule],
  providers: [BusinessService],
})
export class BusinessModule {}

在业务服务中注入：

import { Inject, Injectable } from '@nestjs/common';
import { QueuesService } from './queues.service';

@Injectable()
export class BusinessService {
  constructor(
    @Inject('FooQueueService') private readonly fooQueue: QueuesService,
    @Inject('BarQueueService') private readonly barQueue: QueuesService,
  ) {}

  async handleMultiQueueTasks() {
    await this.fooQueue.sendMessage('foo-task');
    await this.barQueue.sendMessage('bar-task');
  }
}

优化：自定义装饰器简化注入 #

可以创建自定义装饰器，让注入语法更简洁：

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

export const InjectQueue = (queueName: string) => Inject(`${queueName}QueueService`);

之后注入时可以这样写：

constructor(
  @InjectQueue('Foo') private readonly fooQueue: QueuesService,
  @InjectQueue('Bar') private readonly barQueue: QueuesService,
) {}

关于你提出的三种方案的补充说明 #

• 方案1（多次导入模块+标识）：通过上述改进的forRoot方法即可实现，每次导入时指定唯一令牌，NestJS会识别不同的提供者，不会出现冲突。
• 方案2（导出所有队列）：手动创建服务实例违背了NestJS的依赖注入原则，会丢失生命周期管理、依赖自动注入等核心特性，不推荐使用。
• 方案3（导出已导入模块）：这是最符合NestJS模块化思想的方案，上述实现就是基于这个思路优化的，通过专属队列模块封装配置和令牌，保证了模块的独立性和可复用性。

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