Java-205 RabbitMQ 工作模式实战：Work Queue 负载均衡 + fanout 发布订阅（手动ACK/QoS/临时队列）

TL;DR

场景：同一队列多消费者分摊任务 + 一条消息广播给多个订阅方
结论：Work Queue 依赖 manual ack + basicQos 控制分发；fanout 依赖交换器绑定与临时队列实现"一对多"
产出：给出 Java 生产/消费代码骨架、未命名交换器用法、临时队列与 binding 的验证路径

RabbitMQ 工作模式

Work Queue

生产者发送消息，启动多个消费者实例来消费消息，每个消费者仅消费部分信息，可以达到负载均衡的效果。

NewTask

java 复制代码

package icu.wzk.demo;
public class TestTask {

    private static final String HOST = "localhost";
    private static final String VIRTUAL_HOST = "/";
    private static final String USERNAME = "admin";
    private static final String PASSWORD = "secret";
    private static final int PORT = 5672;

    private static final String QUEUE_NAME = "wzk-icu";

    private static final String[] WORKS = {
            "hello.",
            "hello..",
            "hello...",
            "hello....",
            "hello.....",
            "hello......",
            "hello.......",
            "hello........",
            "hello.........",
            "hello.........."
    };

    public static void main(String[] args) {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost(HOST);
        factory.setVirtualHost(VIRTUAL_HOST);
        factory.setUsername(USERNAME);
        factory.setPassword(PASSWORD);
        factory.setPort(PORT);

        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {

            channel.queueDeclare(QUEUE_NAME, false, false, false, null);
            String exchange = "";
            for (String work : WORKS) {
                channel.basicPublish(
                        exchange,
                        QUEUE_NAME,
                        null,
                        work.getBytes(StandardCharsets.UTF_8)
                );
                System.out.println(" [x] Sent '" + work + "'");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

对应的执行结果如下所示：

TestTask2

java 复制代码

package icu.wzk.demo;
public class TestTask2 {

    private static final String TASK_QUEUE_NAME = "wzk-icu";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        factory.setPort(5672);
        factory.setVirtualHost("/");
        factory.setUsername("admin");
        factory.setPassword("secret");

        // false = 手动 ack（推荐配合 basicQos）
        boolean autoAck = false;

        try (Connection conn = factory.newConnection(); Channel channel = conn.createChannel()) {
            // 每次只拉取 1 条，避免一次性堆给消费者
            channel.basicQos(1);
            channel.queueDeclare(TASK_QUEUE_NAME, false, false, false, null);

            DeliverCallback deliverCallback = (consumerTag, delivery) -> {
                String task = new String(delivery.getBody(), StandardCharsets.UTF_8);
                long tag = delivery.getEnvelope().getDeliveryTag();
                System.out.println(" [x] Received '" + task + "'");
                try {
                    doWork(task);
                    System.out.println(" [x] Done");
                    // 手动确认
                    channel.basicAck(tag, false);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    // 中断时重回队列
                    channel.basicNack(tag, false, true);
                } catch (Exception e) {
                    // 失败时重回队列（按需改为 false 丢弃）
                    channel.basicNack(tag, false, true);
                }
            };

            channel.basicConsume(TASK_QUEUE_NAME, autoAck, deliverCallback, consumerTag -> {});
            // 阻塞主线程，保持进程存活
            synchronized (TestTask2.class) {
                try {
                    TestTask2.class.wait();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }
    }

    private static void doWork(String task) throws InterruptedException {
        System.out.println("task = " + task);
        for (char ch : task.toCharArray()) {
            if (ch == '.') {
                Thread.sleep(1000);
            }
        }
    }

}

执行结果如下所示：

发布订阅

在RabbitMQ消息队列系统中，fanout类型交换器是一种重要的消息分发机制。这种交换器的工作方式类似于广播模式，具有以下特点：

消息分发机制：

生产者将消息发送到Exchange时，会完全忽略RoutingKey（路由键）的设置
Exchange会将收到的每一条消息复制并推送到所有绑定到该Exchange的队列
每个消费者队列都会收到完整的消息副本

队列绑定过程：

每个消费者在订阅时，RabbitMQ会自动为其创建一个专属队列
这个新创建的队列会与指定的Exchange建立绑定关系
绑定过程不涉及任何路由规则或过滤条件

典型应用场景：

实时通知系统（如股票行情推送）
日志收集系统（多个日志处理服务同时接收日志）
事件广播系统（订单创建事件通知多个微服务）

技术实现细节：

python 复制代码

# 生产者示例代码
channel.exchange_declare(exchange='logs', exchange_type='fanout')
channel.basic_publish(exchange='logs', routing_key='', body=message)

# 消费者示例代码
result = channel.queue_declare(queue='', exclusive=True)
channel.queue_bind(exchange='logs', queue=result.method.queue)

与传统点对点模式的区别：

传统模式：一个消息只能被一个消费者处理
fanout模式：一个消息会被所有消费者处理
消息生命周期：在fanout模式下，消息会被复制多份分别存储在不同队列中

这种模式特别适合需要"一对多"消息分发的场景，确保所有订阅者都能及时获取完整的消息内容。由于不依赖RoutingKey，系统设计更加简单，但需要注意可能带来的资源消耗问题，因为每条消息都会被复制多份。

交换器的类型前面已经介绍过了：

● direct

● topic

● headers

● fanout

发布订阅使用 fanout，创建交换器叫做 logs：

shell 复制代码

channel.exchangeDeclare("logs", "fanout");

fanout 交换器很简单，从名字可以看到叫用风扇吹出去，将收到的消息发送给它知道的所有队列。

shell 复制代码

rabbitmqctl list_exchanges

列出 RabbitMQ 的交换器，包括了 amq.* 和默认未命名的交换器。

未命名交换器

在前面我们虽然没有指定交换器，但是依然可以向队列发送消息，这是因为我们使用了默认的交换器。

java 复制代码

channel.basicPublish("", "hello", null, message.getBytes());

第一个参数就是交换器的名称，为空字符串，直接使用 RoutingKey 向队列发送消息，如果该 RoutingKey 指定的队列存在的话。

如果我们要向指定的交换发布器发送消息：

java 复制代码

channel.basicPublish("logs", "", null, message.getBytes());

临时队列

生产者和消费者都是通过队列名称来发送和接收该队列中的消息。在使用RabbitMQ时，创建队列的过程需要注意以下几点：

队列创建机制：

当连接到RabbitMQ时，通常需要创建一个新的空队列
队列命名方式有两种选择：
- 自定义命名：可以指定一个有意义的队列名称，如"order_processing_queue"
- 自动生成：可以让RabbitMQ服务器生成随机队列名（如"amq.gen-JzTY20BRgKO-HjmUJj0wLg"）

队列生命周期管理：

临时队列特性：当声明队列时将"exclusive"参数设为true，该队列就变成独占队列
自动删除机制：对于独占队列，一旦消费者断开连接，RabbitMQ会自动删除该队列
持久化队列：如果需要长期保留队列，可以设置"durable"参数为true

应用场景示例：

临时任务处理：使用自动生成的队列名处理一次性任务
RPC调用：客户端创建临时队列接收服务端响应
消息广播：多个消费者各自创建独占队列绑定到同一个交换机

注意事项：

生产环境中建议使用明确的队列命名规范
自动删除队列适合临时性消息交换场景
确保消费者异常断开时队列能正确释放资源

java 复制代码

String queueName = channel.queueDeclare().getQueue();

上述代码我们声明了一个非持久化的、排他的、自动删除的队列，并且名字都是服务器随机生成的。

进行绑定

在创建了消息队列和fanout类型的交换器之后，我们需要将两者进行绑定，让交换器将消息发送给该队列。fanout交换器会将收到的所有消息广播到所有与之绑定的队列中，这种模式非常适合需要消息广播的场景，比如系统日志分发或实时通知推送。

下面是具体的绑定操作示例代码：

shell 复制代码

channel.queueBind(queueName, "logs", "");

这段代码中各个参数的含义是：

queueName：要绑定的队列名称
logs：交换器的名称
""：路由键（routing key），在fanout类型中不需要使用，因此为空字符串

此时，logs 交换器会将接收到的所有消息无条件地追加到我们的队列中。为了验证绑定是否成功，可以使用下面的命令列出 RabbitMQ 中交换器的绑定关系：

shell 复制代码

rabbitmqctl list_bindings

这个命令会显示类似如下的输出：

复制代码

exchange_name    queue_name    routing_key
logs             queue1        ""
logs             queue2        ""

输出结果会清晰地展示每个交换器与队列之间的绑定关系，包括交换器名称、队列名称和使用的路由键。在fanout类型的绑定中，路由键通常会显示为空字符串，因为fanout交换器会忽略路由键的设置。

错误速查

症状	根因定位	修复
多消费者但分发不均、某个消费者"吃撑"	未设置 basicQos 或 prefetch 过大	看消费者侧吞吐与未确认数（unacked）是否偏高 `channel.basicQos(1..N)`；manual ack 后再调优 N
消费者异常后消息丢失	`autoAck=true` 或提前 ack	查 `basicConsume` 的 autoAck 参数、日志中 ack 时机设 `autoAck=false`；仅在业务完成后 `basicAck`
失败消息无限重试、队列"打转"	`basicNack(..., requeue=true)` 对不可恢复错误也重回队列	观察同一消息反复出现，且无退避区分可恢复/不可恢复：不可恢复 `requeue=false` 或走 DLX/重试队列
重启后队列/消息消失	队列非持久化 + 消息非持久化	看 `queueDeclare(durable=false)`、发布属性是否为 persistent 生产：durable queue + persistent message；配合镜像/Quorum 队列策略视需求
发布订阅消费者断开后队列没了	使用临时队列 exclusive/auto-delete 的预期行为	`queueDeclare(queue="", exclusive=true)` 或 server 生成队列名需要持久订阅就改为命名队列 + durable；临时订阅保持现状
fanout 下设置 routingKey 但无效果	fanout 忽略 routingKey	检查 `exchange_type=fanout` 需要按 key 路由就改 direct/topic；fanout 保持 routingKey 为空即可
发送到 exchange 后消费者收不到	未 queueBind 或 bind 到错误 exchange	`rabbitmqctl list_bindings` 看是否存在绑定确认 `queueBind(queueName,"logs","")` 与 exchange 名一致
使用默认交换器发送失败（无路由）	routingKey（队列名）不存在或拼错	生产者 `basicPublish` 的 routingKey 与实际队列名比对先确保 `queueDeclare` 创建目标队列；routingKey 必须等于队列名
消费端进程退出导致不再消费	try-with-resources 结束或主线程未阻塞	看 main 是否退出、连接是否关闭保持进程存活（你用 wait() 方式可行）；或用更标准的生命周期管理
连接失败/权限错误	vhost/用户名密码/权限不匹配	RabbitMQ 日志与连接异常栈校验 vhost 存在、用户对 vhost 的 configure/write/read 权限

其他系列

🚀 AI篇持续更新中（长期更新）

AI炼丹日志-29 - 字节跳动 DeerFlow 深度研究框斜体样式架私有部署测试上手架构研究 ，持续打造实用AI工具指南！
AI研究-132 Java 生态前沿 2025：Spring、Quarkus、GraalVM、CRaC 与云原生落地
🔗 AI模块直达链接

💻 Java篇持续更新中（长期更新）

Java-196 消息队列选型：RabbitMQ vs RocketMQ vs Kafka

MyBatis 已完结，Spring 已完结，Nginx已完结，Tomcat已完结，分布式服务已完结，Dubbo已完结，MySQL已完结，MongoDB已完结，Neo4j已完结，FastDFS 已完结，OSS已完结，GuavaCache已完结，EVCache已完结，RabbitMQ正在更新... 深入浅出助你打牢基础！
🔗 Java模块直达链接

📊 大数据板块已完成多项干货更新（300篇）：

包括 Hadoop、Hive、Kafka、Flink、ClickHouse、Elasticsearch 等二十余项核心组件，覆盖离线+实时数仓全栈！
大数据-278 Spark MLib - 基础介绍机器学习算法梯度提升树 GBDT案例详解
🔗 大数据模块直达链接