一、概述

在多人协作开发场景中,多个开发者同时启动全套微服务,共用同一套 RabbitMQ Broker。

由于所有实例消费同一个队列,A 电脑产生的消息会被 B 电脑的消费者抢走,导致开发调试混乱、消息丢失、功能异常。

本文介绍一种零侵入业务逻辑的实例隔离方案:通过为每个开发者的本地环境分配唯一标识,动态创建独立的消息队列和路由键,实现"自己发的消息只被自己消费"。

1.1 问题场景

改造前(消息串扰):
┌─────────────────────────────────────────────┐
│                RabbitMQ Broker               │
│                                              │
│  ┌──────────────────────────────────────┐   │
│  │ Queue: kb.notification.queue          │   │
│  │  ┌─────┐ ┌─────┐ ┌─────┐            │   │
│  │  │ msg │ │ msg │ │ msg │ ← 三台电脑  │   │
│  │  │  A  │ │  B  │ │  C  │   的消息混  │   │
│  │  └─────┘ └─────┘ └─────┘   在一起    │   │
│  └──────────────────────────────────────┘   │
│                                              │
│  消费者A 消费了消息B ❌                         │
│  消费者B 消费了消息C ❌                         │
│  消费者C 消费了消息A ❌                         │
└─────────────────────────────────────────────┘

图片.png

改造后(实例隔离):
┌──────────────────────────────────────────────────────────┐
│                    RabbitMQ Broker                        │
│                                                          │
│  ┌─────────────────────────────────────────────────┐    │
│  │ Queue: kb.notification.queue.MacBook-Pro         │    │
│  │  ┌─────┐                                        │    │
│  │  │ msg │ ← 只有 A 的消息                         │    │
│  │  │  A  │                                        │    │
│  │  └─────┘                                        │    │
│  └─────────────────────────────────────────────────┘    │
│  ┌─────────────────────────────────────────────────┐    │
│  │ Queue: kb.notification.queue.iMac                │    │
│  │  ┌─────┐                                        │    │
│  │  │ msg │ ← 只有 B 的消息                         │    │
│  │  │  B  │                                        │    │
│  │  └─────┘                                        │    │
│  └─────────────────────────────────────────────────┘    │
│                                                          │
│  消费者A 只消费自己的消息 ✅                               │
│  消费者B 只消费自己的消息 ✅                               │
└──────────────────────────────────────────────────────────┘

图片.png

1.2 核心设计思想

交换机共享,队列和路由键隔离。

图片.png

资源隔离策略原因
Exchange全局共享交换机是纯路由设施,无状态,多实例共用不产生干扰
Queue实例隔离每个实例独立队列,消息物理隔离
Routing Key实例隔离确保消息只路由到本实例的队列
Binding实例隔离绑定关系按实例 ID 精确匹配

1.3 涉及模块

本项目包含7个微服务模块,其中5个使用了 RabbitMQ:

模块角色交换机和队列数
kb-common公共基础设施提供 InstanceIdentifier
kb-document生产者1个交换机,1个队列
kb-foundation消费者3个交换机,4个队列
kb-statistics消费者1个交换机,3个队列
kb-ai生产者+消费者2个交换机,2个队列
kb-file生产者+消费者1个交换机,1个队列

二、核心组件:InstanceIdentifier

2.1 设计思路

需要一个全局唯一的实例标识,同一台电脑上的所有微服务获取到的 ID 必须一致。通过三级降级策略保证标识的唯一性和可配置性。

图片.png

2.2 标识解析优先级

优先级来源示例值适用场景
1(推荐)app.instance.id 配置dev-01, zhangsan生产环境、需要精确控制的场景
2(默认)本机 hostnameMacBook-Pro, ThinkPad-X1本地开发,自动隔离
3(兜底)随机 UUIDlocal-a1b2c3d4hostname 获取失败时的兜底

2.3 创建 InstanceIdentifier

在 kb-common 模块中创建 src/main/java/com/knowledge/base/common/config/InstanceIdentifier.java:

package com.knowledge.base.common.config;

import lombok.Getter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.net.InetAddress;
import java.util.UUID;

/**
 * 实例标识符
 *
 * <p>为每个运行实例生成唯一标识,实现 RabbitMQ 队列和路由键的实例级隔离。
 * 同一台机器上的所有微服务获取到的 ID 一致。</p>
 *
 * <p>解析优先级:app.instance.id 配置 > 本机 hostname > 随机 UUID</p>
 *
 * @author 苏三
 * @since 1.0.0
 */
@Slf4j
@Component
public class InstanceIdentifier implements InitializingBean {

    @Value("${app.instance.id:}")
    private String configuredId;

    @Getter
    private String id;

    @Override
    public void afterPropertiesSet() {
        this.id = resolve();
        log.info("当前实例标识(instanceId):{}", this.id);
    }

    private String resolve() {
        // 1. 优先使用显式配置
        if (configuredId != null && !configuredId.trim().isEmpty()) {
            return sanitize(configuredId.trim());
        }

        // 2. 降级使用本机 hostname
        try {
            String hostname = InetAddress.getLocalHost().getHostName();
            if (hostname != null && !hostname.isBlank()) {
                int dotIndex = hostname.indexOf('.');
                if (dotIndex > 0) {
                    hostname = hostname.substring(0, dotIndex);
                }
                return sanitize(hostname);
            }
        } catch (Exception e) {
            log.warn("获取本机 hostname 失败:{}", e.getMessage());
        }

        // 3. 最终降级:随机标识
        return "local-" + UUID.randomUUID().toString().substring(0, 8);
    }

    /**
     * 清理非法字符,仅保留字母、数字、点号、下划线和短横线
     */
    private String sanitize(String raw) {
        return raw.replaceAll("[^a-zA-Z0-9._-]", "-");
    }
}

2.4 关键设计点

  • InitializingBean** 接口**:在 Spring 容器初始化完成后立即执行,确保所有 Bean 注入前 ID 已就绪
  • sanitize()** 方法**:hostname 中可能包含空格等 RabbitMQ 不支持的字符,统一替换为 -
  • hostname 截断:MacBook-Pro.local 只取 MacBook-Pro,去掉域名后缀
  • 启动日志:打印确定的 instanceId,方便排查隔离问题

三、改造前的准备工作

3.1 理解改造范围

每个需要隔离的模块需要完成以下三步改造:

图片.png

3.2 命名规范

类型改造前改造后
队列名kb.notification.review.queuekb.notification.review.queue.{instanceId}
路由键(生产者)notification.review.submittednotification.review.{instanceId}.submitted
路由键(绑定)notification.review.#notification.review.{instanceId}.*
监听器@RabbitListener(queues = "固定名")@RabbitListener(queues = "#{@queueBean.name}")

四、kb-foundation 模块改造

kb-foundation 是消息消费者的核心模块,消费通知、审核、操作日志、配置更新四类消息。

4.1 改造 RabbitMQConfig

修改 kb-foundation/src/main/java/com/knowledge/base/foundation/config/RabbitMQConfig.java:

package com.knowledge.base.foundation.config;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import com.knowledge.base.common.config.InstanceIdentifier;
import jakarta.annotation.Resource;
import org.springframework.amqp.core.*;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.support.converter.DefaultClassMapper;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * RabbitMQ 消息队列配置
 *
 * <p>队列名与路由键使用 InstanceIdentifier 进行实例隔离,
 * 确保多开发者本地环境的消息互不干扰。</p>
 *
 * @author 苏三
 * @since 1.0.0
 */
@Configuration
public class RabbitMQConfig {

    @Resource
    private InstanceIdentifier instanceIdentifier;

    // ======================== 交换机声明(全局共享) ========================

    public static final String NOTIFICATION_EXCHANGE = "kb.notification.exchange";

    @Bean
    public TopicExchange notificationExchange() {
        return new TopicExchange(NOTIFICATION_EXCHANGE, true, false);
    }

    public static final String CONFIG_EXCHANGE = "kb.config.exchange";

    @Bean
    public DirectExchange configExchange() {
        return new DirectExchange(CONFIG_EXCHANGE, true, false);
    }

    public static final String OPERATION_LOG_EXCHANGE = "kb.operationlog.exchange";

    @Bean
    public TopicExchange operationLogExchange() {
        return new TopicExchange(OPERATION_LOG_EXCHANGE, true, false);
    }

    // ======================== 通用通知队列 ========================

    public String notificationQueueName() {
        return "kb.notification.queue." + instanceIdentifier.getId();
    }

    public String notificationRoutingKey() {
        return "notification." + instanceIdentifier.getId() + ".#";
    }

    @Bean
    public Queue notificationQueue() {
        return QueueBuilder.durable(notificationQueueName()).build();
    }

    @Bean
    public Binding notificationBinding() {
        return BindingBuilder.bind(notificationQueue())
                .to(notificationExchange())
                .with(notificationRoutingKey());
    }

    // ======================== 审核通知队列 ========================

    public String reviewNotificationQueueName() {
        return "kb.notification.review.queue." + instanceIdentifier.getId();
    }

    public String reviewNotificationRoutingKey() {
        return "notification.review." + instanceIdentifier.getId() + ".*";
    }

    @Bean
    public Queue reviewNotificationQueue() {
        return QueueBuilder.durable(reviewNotificationQueueName()).build();
    }

    @Bean
    public Binding reviewNotificationBinding() {
        return BindingBuilder.bind(reviewNotificationQueue())
                .to(notificationExchange())
                .with(reviewNotificationRoutingKey());
    }

    // ======================== 系统配置队列 ========================

    public String configQueueName() {
        return "kb.config.queue." + instanceIdentifier.getId();
    }

    public String configRoutingKey() {
        return "config." + instanceIdentifier.getId() + ".update";
    }

    @Bean
    public Queue configQueue() {
        return QueueBuilder.durable(configQueueName()).build();
    }

    @Bean
    public Binding configBinding() {
        return BindingBuilder.bind(configQueue())
                .to(configExchange())
                .with(configRoutingKey());
    }

    // ======================== 操作日志队列 ========================

    public String operationLogQueueName() {
        return "kb.operationlog.queue." + instanceIdentifier.getId();
    }

    public String operationLogRoutingKey() {
        return "operationlog." + instanceIdentifier.getId() + ".#";
    }

    @Bean
    public Queue operationLogQueue() {
        return QueueBuilder.durable(operationLogQueueName()).build();
    }

    @Bean
    public Binding operationLogBinding() {
        return BindingBuilder.bind(operationLogQueue())
                .to(operationLogExchange())
                .with(operationLogRoutingKey());
    }

    // ======================== 消息转换器 ========================

    @Bean
    public Jackson2JsonMessageConverter jackson2JsonMessageConverter() {
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.registerModule(new JavaTimeModule());
        Jackson2JsonMessageConverter converter = new Jackson2JsonMessageConverter(objectMapper);
        DefaultClassMapper classMapper = new DefaultClassMapper();
        classMapper.setTrustedPackages(
                "com.knowledge.base.common.event",
                "com.knowledge.base.foundation.dto",
                "java.util",
                "java.lang"
        );
        converter.setClassMapper(classMapper);
        return converter;
    }

    @Bean
    public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory,
                                          Jackson2JsonMessageConverter messageConverter) {
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        rabbitTemplate.setMessageConverter(messageConverter);
        return rabbitTemplate;
    }
}

4.2 改造监听器 — 审核通知

修改 ReviewNotificationListener.java,将固定队列名改为 SpEL 动态引用:

// 改造前:
@RabbitListener(queues = "kb.notification.review.queue")

// 改造后:
@RabbitListener(queues = "#{@reviewNotificationQueue.name}")

#{@reviewNotificationQueue.name} 是 Spring SpEL 表达式,运行时从 Spring 容器中获取名为 reviewNotificationQueue 的 Queue Bean,调用其 getName() 方法获取实际队列名。

4.3 改造监听器 — 操作日志

修改 OperationLogMQListener.java:

// 改造前:
@RabbitListener(queues = "kb.operationlog.queue")

// 改造后:
@RabbitListener(queues = "#{@operationLogQueue.name}")

五、kb-document 模块改造

kb-document 是消息的生产者,同时也是审核通知交换机和队列的声明者(确保生产者启动时队列已存在,避免消息被丢弃)。

5.1 改造 RabbitMQConfig

修改 kb-document/src/main/java/com/knowledge/base/document/config/RabbitMQConfig.java:

package com.knowledge.base.document.config;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import com.knowledge.base.common.config.InstanceIdentifier;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.*;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.support.converter.DefaultClassMapper;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * RabbitMQ 消息序列化与交换机声明配置
 *
 * <p>声明通知交换机、队列及绑定,确保 kb-document 发布消息时
 * 交换机/队列已存在,避免因 kb-foundation 尚未启动导致消息被静默丢弃。</p>
 *
 * <p>启用 publisher confirms 和 mandatory 模式,主动检测消息发送失败。</p>
 *
 * @author 苏三
 * @since 1.0.0
 */
@Slf4j
@Configuration
public class RabbitMQConfig {

    @Resource
    private InstanceIdentifier instanceIdentifier;

    // ======================== 交换机声明(全局共享) ========================

    public static final String NOTIFICATION_EXCHANGE = "kb.notification.exchange";

    @Bean
    public TopicExchange notificationExchange() {
        return new TopicExchange(NOTIFICATION_EXCHANGE, true, false);
    }

    // ======================== 审核通知队列声明 ========================

    public String reviewNotificationQueueName() {
        return "kb.notification.review.queue." + instanceIdentifier.getId();
    }

    public String reviewNotificationRoutingKey() {
        return "notification.review." + instanceIdentifier.getId() + ".*";
    }

    @Bean
    public Queue reviewNotificationQueue() {
        return QueueBuilder.durable(reviewNotificationQueueName()).build();
    }

    @Bean
    public Binding reviewNotificationBinding() {
        return BindingBuilder.bind(reviewNotificationQueue())
                .to(notificationExchange())
                .with(reviewNotificationRoutingKey());
    }

    // ======================== 消息转换器 ========================

    @Bean
    public Jackson2JsonMessageConverter jackson2JsonMessageConverter() {
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.registerModule(new JavaTimeModule());
        Jackson2JsonMessageConverter converter = new Jackson2JsonMessageConverter(objectMapper);
        DefaultClassMapper classMapper = new DefaultClassMapper();
        classMapper.setTrustedPackages(
                "com.knowledge.base.common.event",
                "com.knowledge.base.document.dto",
                "java.util",
                "java.lang"
        );
        converter.setClassMapper(classMapper);
        return converter;
    }

    @Bean
    public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory,
                                          Jackson2JsonMessageConverter messageConverter) {
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        rabbitTemplate.setMessageConverter(messageConverter);

        // 启用发布确认回调
        rabbitTemplate.setConfirmCallback((correlationData, ack, cause) -> {
            if (!ack && correlationData != null) {
                log.error("消息发送到交换机失败:id={}, cause={}",
                        correlationData.getId(),
                        cause != null ? cause : "交换机不存在或不可达");
            }
        });

        // 启用 mandatory 模式,检测消息是否成功路由到队列
        rabbitTemplate.setMandatory(true);
        rabbitTemplate.setReturnsCallback(returned -> {
            log.error("消息未路由到任何队列:exchange={}, routingKey={}, " +
                    "replyCode={}, replyText={}",
                    returned.getExchange(), returned.getRoutingKey(),
                    returned.getReplyCode(), returned.getReplyText());
        });

        return rabbitTemplate;
    }
}

5.2 改造生产者 — 审核事件发布

修改 DocumentReviewServiceImpl.java,将路由键加入实例标识:

@Resource
private InstanceIdentifier instanceIdentifier;

private static final String REVIEW_EXCHANGE = "kb.notification.exchange";

/**
 * 构建实例隔离的审核通知路由键
 * 示例:notification.review.MacBook-Pro.submitted
 */
private String reviewRoutingKey(String eventType) {
    return "notification.review." + instanceIdentifier.getId() + "." + eventType;
}

// 发送消息时使用动态路由键:
rabbitTemplate.convertAndSend(
    REVIEW_EXCHANGE,
    reviewRoutingKey("submitted"),  // 不再硬编码为 "notification.review.submitted"
    event,
    correlationData
);

5.3 改造生产者 — 统计事件发布

修改 StatisticsEventPublisher.java:

@Resource
private InstanceIdentifier instanceIdentifier;

private String viewRoutingKey() {
    return "statistics.view." + instanceIdentifier.getId() + ".record";
}

private String likeRoutingKey() {
    return "statistics.like." + instanceIdentifier.getId() + ".record";
}

private String commentRoutingKey() {
    return "statistics.comment." + instanceIdentifier.getId() + ".record";
}

5.4 生产者与消费者的路由键匹配关系

图片.png


六、kb-statistics 模块改造

kb-statistics 是纯消费者模块,消费浏览、点赞、评论三类统计事件。

6.1 改造 StatisticsMQConfig

修改 kb-statistics/src/main/java/com/knowledge/base/statistics/config/StatisticsMQConfig.java:

package com.knowledge.base.statistics.config;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import com.knowledge.base.common.config.InstanceIdentifier;
import jakarta.annotation.Resource;
import org.springframework.amqp.core.*;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.amqp.support.converter.DefaultClassMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 统计服务 RabbitMQ 配置
 *
 * <p>定义统计事件的消息队列、交换机和绑定关系。
 * 队列名与路由键使用 InstanceIdentifier 进行实例隔离。</p>
 *
 * @author 苏三
 * @since 1.0.0
 */
@Configuration
public class StatisticsMQConfig {

    @Resource
    private InstanceIdentifier instanceIdentifier;

    // ======================== 交换机 ========================

    public static final String STATISTICS_EXCHANGE = "kb.statistics.exchange";

    @Bean
    public TopicExchange statisticsExchange() {
        return new TopicExchange(STATISTICS_EXCHANGE, true, false);
    }

    // ======================== 队列名(实例隔离) ========================

    public String statisticsViewQueueName() {
        return "kb.statistics.view.queue." + instanceIdentifier.getId();
    }

    public String statisticsLikeQueueName() {
        return "kb.statistics.like.queue." + instanceIdentifier.getId();
    }

    public String statisticsCommentQueueName() {
        return "kb.statistics.comment.queue." + instanceIdentifier.getId();
    }

    // ======================== 路由键 ========================

    public String viewRoutingKey() {
        return "statistics.view." + instanceIdentifier.getId() + ".*";
    }

    public String likeRoutingKey() {
        return "statistics.like." + instanceIdentifier.getId() + ".*";
    }

    public String commentRoutingKey() {
        return "statistics.comment." + instanceIdentifier.getId() + ".*";
    }

    // ======================== 队列 Bean ========================

    @Bean
    public Queue statisticsViewQueue() {
        return QueueBuilder.durable(statisticsViewQueueName()).build();
    }

    @Bean
    public Queue statisticsLikeQueue() {
        return QueueBuilder.durable(statisticsLikeQueueName()).build();
    }

    @Bean
    public Queue statisticsCommentQueue() {
        return QueueBuilder.durable(statisticsCommentQueueName()).build();
    }

    // ======================== 绑定 ========================

    @Bean
    public Binding statisticsViewBinding() {
        return BindingBuilder.bind(statisticsViewQueue())
                .to(statisticsExchange())
                .with(viewRoutingKey());
    }

    @Bean
    public Binding statisticsLikeBinding() {
        return BindingBuilder.bind(statisticsLikeQueue())
                .to(statisticsExchange())
                .with(likeRoutingKey());
    }

    @Bean
    public Binding statisticsCommentBinding() {
        return BindingBuilder.bind(statisticsCommentQueue())
                .to(statisticsExchange())
                .with(commentRoutingKey());
    }

    // ======================== 消息转换器 ========================

    @Bean
    public Jackson2JsonMessageConverter jackson2JsonMessageConverter() {
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.registerModule(new JavaTimeModule());
        objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);

        Jackson2JsonMessageConverter converter = new Jackson2JsonMessageConverter(objectMapper);
        DefaultClassMapper classMapper = new DefaultClassMapper();
        classMapper.setTrustedPackages(
                "com.knowledge.base.common.event",
                "com.knowledge.base.statistics.dto",
                "java.util",
                "java.lang"
        );
        converter.setClassMapper(classMapper);
        return converter;
    }
}

6.2 改造监听器 — 统计事件

修改 StatisticsMQListener.java,三个 @RabbitListener 注解全部改为 SpEL 动态引用:

// 改造前:
@RabbitListener(queues = "kb.statistics.view.queue")
public void handleViewEvent(StatisticsEventDTO event) { ... }

@RabbitListener(queues = "kb.statistics.like.queue")
public void handleLikeEvent(StatisticsEventDTO event) { ... }

@RabbitListener(queues = "kb.statistics.comment.queue")
public void handleCommentEvent(StatisticsEventDTO event) { ... }

// 改造后:
@RabbitListener(queues = "#{@statisticsViewQueue.name}")
public void handleViewEvent(StatisticsEventDTO event) { ... }

@RabbitListener(queues = "#{@statisticsLikeQueue.name}")
public void handleLikeEvent(StatisticsEventDTO event) { ... }

@RabbitListener(queues = "#{@statisticsCommentQueue.name}")
public void handleCommentEvent(StatisticsEventDTO event) { ... }

七、kb-ai 模块改造

kb-ai 是生产者+消费者模块,处理 RAG 索引重建和 KAG 图谱构建消息。

7.1 改造 RabbitConfig(RAG)

修改 kb-ai/src/main/java/com/knowledge/base/ai/config/RabbitConfig.java:

@Resource
private InstanceIdentifier instanceIdentifier;

// ======================== 队列名 ========================

public String ragReindexQueueName() {
    return "rag.reindex.queue." + instanceIdentifier.getId();
}

// ======================== 路由键模式(绑定用) ========================

public String ragReindexRoutingKeyAll() {
    return "rag.reindex." + instanceIdentifier.getId() + ".all";
}

public String ragReindexRoutingKeyByIds() {
    return "rag.reindex." + instanceIdentifier.getId() + ".by_ids";
}

public String ragReindexRoutingKeyDelete() {
    return "rag.reindex." + instanceIdentifier.getId() + ".delete";
}

7.2 改造 KAGRabbitConfig

修改 kb-ai/src/main/java/com/knowledge/base/ai/config/KAGRabbitConfig.java:

@Resource
private InstanceIdentifier instanceIdentifier;

public String kagGraphBuildQueueName() {
    return "kag.graph.build.queue." + instanceIdentifier.getId();
}

public String kagGraphBuildRoutingKeyAll() {
    return "kag.graph.build." + instanceIdentifier.getId() + ".all";
}

public String kagGraphBuildRoutingKeyByIds() {
    return "kag.graph.build." + instanceIdentifier.getId() + ".by_ids";
}

public String kagGraphDeleteRoutingKey() {
    return "kag.graph.delete." + instanceIdentifier.getId();
}

7.3 改造消费者 — RAG 和 KAG

// ReindexConsumer.java
// 改造前:
@RabbitListener(queues = "rag.reindex.queue")
public void handleReindexMessage(ReindexMessage message) { ... }

// 改造后:
@RabbitListener(queues = "#{@ragReindexQueue.name}", ackMode = "MANUAL")
public void handleReindexMessage(ReindexMessage message) { ... }

// KAGReindexConsumer.java 同理:
@RabbitListener(queues = "#{@kagGraphBuildQueue.name}", ackMode = "MANUAL")
public void handleGraphBuildMessage(GraphBuildMessage message) { ... }

7.4 改造生产者 — 路由键加入实例 ID

修改 ReindexServiceImpl.java 和 GraphBuildServiceImpl.java 中的路由键方法:

// ReindexServiceImpl.java
@Resource
private InstanceIdentifier instanceIdentifier;

private String routingKeyAll() {
    return "rag.reindex." + instanceIdentifier.getId() + ".all";
}

private String routingKeyByIds() {
    return "rag.reindex." + instanceIdentifier.getId() + ".by_ids";
}

private String routingKeyDelete() {
    return "rag.reindex." + instanceIdentifier.getId() + ".delete";
}

// GraphBuildServiceImpl.java 同理
private String routingKeyBuildAll() {
    return "kag.graph.build." + instanceIdentifier.getId() + ".all";
}

八、kb-file 模块改造

kb-file 处理文件转码消息,既是生产者也是消费者。

8.1 改造 RabbitMQConfig

修改 kb-file/src/main/java/com/knowledge/base/file/config/RabbitMQConfig.java:

@Resource
private InstanceIdentifier instanceIdentifier;

public static final String TRANSCODE_EXCHANGE = "transcode.exchange";

public String transcodeQueueName() {
    return "transcode.queue." + instanceIdentifier.getId();
}

public String transcodeRoutingKey() {
    return "transcode." + instanceIdentifier.getId();
}

@Bean
public DirectExchange transcodeExchange() {
    return new DirectExchange(TRANSCODE_EXCHANGE, true, false);
}

@Bean
public Queue transcodeQueue() {
    return new Queue(transcodeQueueName(), true, false, false);
}

@Bean
public Binding transcodeBinding() {
    return BindingBuilder.bind(transcodeQueue())
            .to(transcodeExchange())
            .with(transcodeRoutingKey());
}

8.2 改造生产者和消费者

// TranscodeConsumer.java
// 改造前:
@RabbitListener(queues = "transcode.queue")

// 改造后:
@RabbitListener(queues = "#{@transcodeQueue.name}")

// FileServiceImpl.java 路由键改造:
rabbitTemplate.convertAndSend(
    TRANSCODE_EXCHANGE,
    "transcode." + instanceIdentifier.getId(),  // 路由键加入实例 ID
    new TranscodeMessage(fileId, targetFormat)
);

九、kb-common 模块的额外改造

9.1 操作日志切面路由键改造

修改 kb-common/src/main/java/com/knowledge/base/common/aspect/OperationLogAspect.java:

@Resource
private InstanceIdentifier instanceIdentifier;

// 发送操作日志时使用实例隔离的路由键:
rabbitTemplate.convertAndSend(
    "kb.operationlog.exchange",
    "operationlog." + instanceIdentifier.getId() + ".record",
    event
);

十、改造完成后的全貌

改造成果对比

改造前:
  开发者A提交文档 → 发送消息到 kb.notification.review.queue
  开发者B的监听器抢走了这条消息 → B收到通知,A没收到 ❌

改造后:
  开发者A提交文档 → 发送消息到 kb.notification.review.queue.MacBook-Pro
  只有A的监听器才能消费 → A收到通知,B不受影响 ✅

改造成果总表

模块改造内容影响文件数
kb-common新增 InstanceIdentifier.java+1
kb-document修改 RabbitMQConfig、修改 2 个生产者3
kb-foundation修改 RabbitMQConfig、修改 2 个监听器3
kb-statistics修改 StatisticsMQConfig、修改 1 个监听器2
kb-ai修改 RabbitConfig + KAGRabbitConfig、修改 2 个消费者 + 2 个生产者6
kb-file修改 RabbitMQConfig、修改 1 个消费者 + 1 个生产者3
合计6 个模块,1 个核心组件,10 个队列,15 个路由键18

十一、验证测试

11.1 启动验证

启动任意微服务,查看日志中的 instanceId 输出:

当前实例标识(instanceId):MacBook-Pro

11.2 RabbitMQ 管理界面验证

访问 RabbitMQ 管理控制台(默认 http://localhost:15672),切到 Queues 标签页:

改造前看到的队列:
  kb.notification.review.queue
  kb.operationlog.queue
  kb.statistics.view.queue
  ...

改造后看到的队列:
  kb.notification.review.queue.MacBook-Pro  ← 你的
  kb.notification.review.queue.iMac         ← 同事的
  kb.operationlog.queue.MacBook-Pro
  kb.statistics.view.queue.MacBook-Pro
  ...

11.3 功能验证

使用 curl 或 Postman 发起测试请求:

# 1. 登录获取 token
curl -X POST http://localhost:8081/auth/login \
  -H "Content-Type: application/json" \
  -d '{"username":"admin","password":"admin123"}'

# 2. 提交文档审核(使用返回的 token)
curl -X POST http://localhost:8082/document/review/submit/327396046936346624 \
  -H "Authorization: Bearer <token>"

# 3. 检查日志
# kb-document 日志应显示:
#   已发布审核提交事件:documentId=xxx, exchange=kb.notification.exchange,
#   routingKey=notification.review.MacBook-Pro.submitted
#
# kb-foundation 日志应显示:
#   收到文档提交审核事件:documentId=xxx, title=xxx
#   通知已持久化:userId=xxx, type=review, documentId=xxx

# 4. 查看通知中心 — 应该只有一条"新文档待审核"通知

11.4 多实例隔离验证

如果你有两台电脑(或一台电脑上通过 app.instance.id 配置两个不同 ID 启动两套服务):

# 电脑A 的 application.yml
app:
  instance:
    id: dev-A

# 电脑B 的 application.yml
app:
  instance:
    id: dev-B
  1. A 提交文档 → 只有 A 收到通知
  2. B 提交文档 → 只有 B 收到通知
  3. 互相不受干扰

总结

本文详细介绍了一套完整的 RabbitMQ 多开发者实例隔离方案,核心思路是"交换机共享,队列和路由键按实例隔离"。

技术要点

序号要点说明
1InstanceIdentifier三级降级策略获取唯一实例 ID
2队列命名队列名包含 instanceId,如 queue.{id}
3路由键模式路由键包含 instanceId,如 prefix.{id}.action
4SpEL 动态引用@RabbitListener(queues = "#{@bean.name}")
5双向声明生产者同时声明交换机和队列,消息零丢失
6Publisher Confirms主动检测消息发送到交换机的成功/失败
7Mandatory 模式检测消息是否成功路由到队列

通过本文的学习,您应该能够掌握:

  • RabbitMQ Topic Exchange 的路由机制
  • Spring SpEL 表达式在 @RabbitListener 中的高级用法
  • 多开发者环境下的消息隔离策略
  • Publisher Confirms 和 Mandatory 模式的使用
  • Java InitializingBean 接口的实际应用

祝您开发顺利!

最后修改:2026 年 10 月 24 日
如果觉得我的文章对你有用,请随意赞赏