Queue类单例设计是否合理？需为不同消息类型分配独立通道

1. 调整单例实例的区分逻辑 #

当前QueueFactory的单例key仅由type和options生成，完全没考虑泛型T——而TypeScript泛型在运行时会被擦除，所以不管你传入String还是number，运行时的key都是一致的，自然会返回同一个实例。

解决方法是给createQueue方法新增消息类型标识参数，将其纳入单例key的生成逻辑：

// 修改QueueFactory的createQueue方法
export function createQueue<T>(
  type: QueueType,
  options: QueueOptions,
  // 新增：传入消息类型的唯一标识
  messageTypeKey: string
): Queue<T> {
  // 把messageTypeKey加入key的生成规则
  const key = `${type}-${messageTypeKey}-${JSON.stringify(options)}`;
  
  if (!queueRegistry[key]) {
    // 根据类型创建对应队列实例
    queueRegistry[key] = new RabbitMQClient<T>(
      options.exchange,
      options.url,
      options.config
    );
  }
  return queueRegistry[key] as Queue<T>;
}

创建队列时传入对应的类型标识：

const q1 = createQueue<String>(
  QueueFactory.QueueType.RABBITMQ,
  {
    url: process.env.RABBITMQ_URL!,
    exchange: process.env.RABBITMQ_EXCHANGE!,
    config: { durable: true, exchangeType: 'direct' }
  },
  "string-message"
);

const q2 = createQueue<number>(
  QueueFactory.QueueType.RABBITMQ,
  {
    url: process.env.RABBITMQ_URL!,
    exchange: process.env.RABBITMQ_EXCHANGE!,
    config: { durable: true, exchangeType: 'direct' }
  },
  "number-message"
);

2. 确保RabbitMQClient每个实例使用独立通道 #

RabbitMQ的连接（Connection）可以复用，但通道（Channel）应该为每个生产者实例独立创建——这样不同实例的发送操作互相隔离，不会共用通道。

调整RabbitMQClient的实现：

export class RabbitMQClient<T> implements Queue<T> {
  private connection: amqp.Connection | null = null;
  private channel: amqp.Channel | null = null; // 每个实例对应独立通道

  constructor(private exchange: string, private url: string, private config?: RabbitMQConfig) {}

  async connect(): Promise<void> {
    if (!this.connection) {
      this.connection = await amqp.connect(this.url);
    }
    // 每个实例创建专属通道
    this.channel = await this.connection.createChannel();
    // 声明交换机
    await this.channel.assertExchange(this.exchange, this.config?.exchangeType || 'direct', {
      durable: this.config?.durable || true
    });
  }

  async send(message: T, routingKey: string = '', options: Options.Publish = {}): Promise<void> {
    if (!this.channel) await this.connect();
    this.channel.publish(
      this.exchange,
      routingKey,
      Buffer.from(JSON.stringify(message)),
      options
    );
  }

  // consume方法同理，基于当前实例的channel实现
  async consume(
    callback: (message: T | null, error?: QueueError) => void,
    routingKey: string = '',
    queueName: string = ''
  ): Promise<void> {
    if (!this.channel) await this.connect();
    // 基于当前channel实现消费逻辑
  }
}

3. 单例设计是不是错误选择？ #

单例本身没问题，但当前的单例粒度选错了。

原来的逻辑是「同类型+同配置=同一个实例」，但你的需求是「同类型+同配置+同消息类型=同一个实例」，所以只要调整单例的区分维度，把消息类型加进去，单例模式依然适用——这样既保证了同消息类型的生产者复用同一个实例（避免重复创建通道），又让不同消息类型的生产者使用独立实例（对应独立通道）。

如果完全放弃单例，每次创建新实例，会导致频繁创建RabbitMQ通道，反而浪费资源，所以单例模式在这里依然是合理的选择，只是需要调整区分实例的条件。

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