Nest中Service与Queue处理器互依赖导致依赖无法解析问题

问题本质 #

这确实是循环依赖，依赖链如下：

• TransactionProcessor 依赖 TransactionService
• TransactionService 依赖 Bull 队列（由 BullModule 注册）
• Bull 队列需要绑定 TransactionProcessor 作为处理器
  三者形成闭环，导致Nest的DI容器无法按顺序解析依赖，抛出无法找到队列依赖的错误。

解决方法 #

方法一：使用 forwardRef 打破循环 #

通过forwardRef告诉Nest延迟解析依赖，打破闭环：

1. 修改 TransactionModule 中服务的注册：

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

@Module({
  providers: [
    forwardRef(() => TransactionService), 
    TransactionProcessor
  ],
  imports: [
    TypeOrmModule.forFeature([TransactionEntity]),
    PassportModule.register({ defaultStrategy: 'jwt' }),
    BullModule.registerQueue({ name: transactionQueue }),
  ],
  controllers: [TransactionController],
  exports: [TransactionService, BullModule],
})
export class TransactionModule {}

2. 修改 TransactionProcessor 的注入方式：

import { forwardRef, Inject } from '@nestjs/common';
import { Process, Processor } from '@nestjs/bull';
import { TransactionService } from '@src/modules/transaction/transaction.service';
import { Job } from 'bull';

export const transactionQueue = 'TransactionQueue';
export const transactionJob = 'TransactionJob';

@Processor(transactionQueue)
export class TransactionProcessor {
  constructor(
    @Inject(forwardRef(() => TransactionService))
    private readonly _transactionService: TransactionService
  ) {}

  @Process(transactionJob)
  async handleFinalizeTransaction(job: Job) {
    const { transactionId } = job.data;

    try {
      await this._transactionService.finalizeTransaction(transactionId);
    } catch (error) {
      console.error('Error finalizing transaction:', error);
      throw error;
    }
  }
}

方法二：拆分处理器到独立模块 #

将队列处理器单独拆分到子模块，隔离依赖：

1. 创建 transaction-queue.module.ts：

import { BullModule } from '@nestjs/bull';
import { Module } from '@nestjs/common';
import { TransactionModule } from '../transaction.module';
import { TransactionProcessor, transactionQueue } from './transaction.processor';

@Module({
  imports: [
    BullModule.registerQueue({ name: transactionQueue }),
    TransactionModule,
  ],
  providers: [TransactionProcessor],
})
export class TransactionQueueModule {}

2. 修改主 TransactionModule：

@Module({
  providers: [TransactionService],
  imports: [
    TypeOrmModule.forFeature([TransactionEntity]),
    PassportModule.register({ defaultStrategy: 'jwt' }),
    TransactionQueueModule,
  ],
  controllers: [TransactionController],
  exports: [TransactionService],
})
export class TransactionModule {}

额外代码修正 #

你的createTransaction方法存在逻辑问题：添加队列任务时transaction.id还未生成（未保存事务），会导致任务执行时找不到对应数据。需调整顺序：

async createTransaction(user: UserEntity, teacher: UserEntity, amount: number) {
  if (user.tokens < amount) {
    throw new BadRequestException(ErrorMessages.INSUFFICIENT_TOKENS);
  }

  user.tokens -= amount;
  await this._transactionRepository.save(user);

  const transaction = this._transactionRepository.create({
    user,
    teacher,
    amount,
    status: TransactionStatus.ACTIVE,
  });

  // 先保存事务获取ID
  await this._transactionRepository.save(transaction);

  // 再添加队列任务
  await this._transactionQueue.add(
    transactionJob,
    { transactionId: transaction.id },
    { delay: 14 * 24 * 60 * 60 * 1000 },
  );

  return transaction;
}

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