RabbitMQ 5 大核心模式详解（一）：简单模式工作队列模式-平芜编程栈

RabbitMQ 作为一款高性能的开源消息队列，基于 AMQP（高级消息队列协议）实现，凭借其轻量级、高可用、易扩展的特性，被广泛应用于分布式系统的解耦、异步通信、流量削峰等场景。RabbitMQ 的核心能力体现在多种消息投递模式上，本文作为系列第一篇，将深入解析简单模式（Simple Mode）和工作队列模式（Work Queue Mode），结合代码实现与场景分析，让你彻底掌握这两种基础模式的使用。

一、前置知识：RabbitMQ 核心概念

在正式讲解模式之前，先快速回顾 RabbitMQ 的几个核心概念，为后续理解铺路：

生产者（Producer）：发送消息的应用程序。
消费者（Consumer）：接收并处理消息的应用程序。
队列（Queue）：消息的存储容器，RabbitMQ 的消息只能存储在队列中，生产者向队列发消息，消费者从队列取消息。
交换机（Exchange）：在高级模式中负责消息路由，简单模式和工作队列模式中会默认使用内置的默认交换机（""）。
绑定（Binding）：将交换机与队列关联起来的规则，决定消息如何从交换机路由到队列。

二、简单模式（Simple Mode）：一对一的消息通信

2.1 模式原理

简单模式是 RabbitMQ 最基础的模式，也被称为点对点模式，其核心架构是一个生产者、一个队列、一个消费者，消息从生产者直接发送到队列，再由唯一的消费者消费。

核心特点：

生产者通过默认交换机（名称为空字符串）将消息发送到指定队列，默认交换机是直连交换机，会根据消息的routing key匹配队列名称进行路由。
队列是消息的载体，生产者发送的消息会先存储在队列中，消费者主动从队列拉取消息（或队列推送消息给消费者）。
一个队列仅对应一个消费者，消费者消费完消息后，消息会从队列中被移除。

简单模式的架构图如下：

生产者（Producer）→ 队列（Queue）→ 消费者（Consumer）

2.2 代码实现（基于 Java + Spring AMQP）

本文采用 Spring Boot 整合 Spring AMQP 的方式实现，相比原生的 RabbitMQ Client，Spring AMQP 提供了更简洁的 API 和自动配置，开发效率更高。

步骤 1：引入依赖

在pom.xml中添加 Spring Boot 与 RabbitMQ 的整合依赖：

<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency>

步骤 2：配置 RabbitMQ 连接

在application.yml中配置 RabbitMQ 的连接信息：

spring: rabbitmq: host: localhost # RabbitMQ服务地址 port: 5672 # 默认端口 username: guest # 默认用户名 password: guest # 默认密码 virtual-host: / # 默认虚拟主机

步骤 3：声明队列

创建配置类，声明简单模式使用的队列（队列名称为simple.queue）：

import org.springframework.amqp.core.Queue; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @Configuration public class RabbitMQConfig { /** * 声明简单模式的队列 * 队列特点：持久化、非排他、非自动删除 */ @Bean public Queue simpleQueue() { return new Queue("simple.queue", true, false, false); } }

步骤 4：实现生产者（发送消息）

创建生产者类，通过RabbitTemplate发送消息到队列：

import org.springframework.amqp.rabbit.core.RabbitTemplate; import org.springframework.stereotype.Component; import javax.annotation.Resource; @Component public class SimpleProducer { @Resource private RabbitTemplate rabbitTemplate; /** * 发送消息到简单队列 * @param message 消息内容 */ public void sendMessage(String message) { rabbitTemplate.convertAndSend("simple.queue", message); System.out.println("简单模式生产者发送消息：" + message); } }

步骤 5：实现消费者（接收消息）

创建消费者类，监听队列并处理消息：

import org.springframework.amqp.rabbit.annotation.RabbitListener; import org.springframework.stereotype.Component; @Component public class SimpleConsumer { /** * 监听简单队列，消费消息 * @param message 消息内容 */ @RabbitListener(queues = "simple.queue") public void consumeMessage(String message) { System.out.println("简单模式消费者接收消息：" + message); // 这里可以添加消息处理逻辑，比如业务逻辑调用、数据存储等 } }

步骤 6：测试代码

创建测试类，调用生产者发送消息：

import org.junit.jupiter.api.Test; import org.springframework.boot.test.context.SpringBootTest; import javax.annotation.Resource; @SpringBootTest public class SimpleModeTest { @Resource private SimpleProducer simpleProducer; @Test public void testSendMessage() { simpleProducer.sendMessage("Hello, RabbitMQ Simple Mode!"); // 休眠1秒，确保消费者有时间处理消息 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } }

运行测试后，控制台会输出生产者发送的消息和消费者接收的消息，说明简单模式的消息通信成功。

2.3 场景分析

简单模式适用于一对一的消息通信场景，典型应用场景包括：

简单的异步通知：比如用户注册后，发送一封激活邮件，生产者发送注册用户信息到队列，消费者接收后调用邮件发送接口。
单一任务的处理：比如后台系统接收到一个数据导入请求，生产者将请求参数发送到队列，消费者接收后执行数据导入操作。
日志收集（简单场景）：比如小型应用的日志收集，生产者将日志消息发送到队列，消费者接收后将日志写入文件。

注意：简单模式的局限性在于，当消费者处理能力不足时，消息会在队列中堆积，无法通过横向扩展消费者来提高处理效率，这时候就需要用到工作队列模式。

三、工作队列模式（Work Queue Mode）：一对多的消息分发

3.1 模式原理

工作队列模式也被称为任务队列模式（Task Queue），其核心架构是一个生产者、一个队列、多个消费者，消息从生产者发送到队列后，由多个消费者竞争消费，每个消息只会被其中一个消费者处理。

核心特点：

生产者依然通过默认交换机将消息发送到指定队列，队列存储消息。
多个消费者监听同一个队列，RabbitMQ 默认采用轮询（Round-Robin）策略分发消息，即依次将消息分发给不同的消费者。
支持消息确认（ACK）机制，确保消息被消费者处理完成后才从队列中移除，避免消息丢失。
可以通过设置消费者的prefetchCount（预取数量），控制消费者一次获取的消息数量，实现负载均衡。

工作队列模式的架构图如下：

生产者（Producer）→ 队列（Queue）→ 消费者1（Consumer1） ↓ → 消费者2（Consumer2） ↓ → 消费者3（Consumer3）

3.2 代码实现（基于 Java + Spring AMQP）

工作队列模式的代码在简单模式的基础上，主要增加多个消费者，并可配置消息确认和预取数量。

步骤 1：复用队列声明（同简单模式）

工作队列模式使用的队列可以复用之前的simple.queue，也可以新建队列（比如work.queue），这里我们新建一个工作队列：

@Configuration public class RabbitMQConfig { // 简单模式队列（复用） @Bean public Queue simpleQueue() { return new Queue("simple.queue", true, false, false); } /** * 声明工作队列 */ @Bean public Queue workQueue() { return new Queue("work.queue", true, false, false); } }

步骤 2：实现生产者（发送消息）

生产者代码与简单模式类似，只是发送到工作队列：

import org.springframework.amqp.rabbit.core.RabbitTemplate; import org.springframework.stereotype.Component; import javax.annotation.Resource; @Component public class WorkProducer { @Resource private RabbitTemplate rabbitTemplate; /** * 发送消息到工作队列 * @param message 消息内容 */ public void sendMessage(String message) { rabbitTemplate.convertAndSend("work.queue", message); System.out.println("工作队列模式生产者发送消息：" + message); } /** * 批量发送消息，用于测试多个消费者的分发效果 * @param count 消息数量 */ public void sendBatchMessage(int count) { for (int i = 1; i <= count; i++) { String message = "Work Queue Message " + i; rabbitTemplate.convertAndSend("work.queue", message); System.out.println("工作队列模式生产者发送消息：" + message); } } }

步骤 3：实现多个消费者（接收消息）

创建两个消费者，监听同一个工作队列，并模拟不同的处理耗时（体现负载均衡的需求）：

消费者 1：

import org.springframework.amqp.rabbit.annotation.RabbitListener; import org.springframework.stereotype.Component; @Component public class WorkConsumer1 { /** * 监听工作队列，消费消息（处理耗时较短） * @param message 消息内容 */ @RabbitListener(queues = "work.queue") public void consumeMessage(String message) { System.out.println("工作队列消费者1接收消息：" + message); // 模拟处理耗时：100毫秒 try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("工作队列消费者1处理完成：" + message); } }

消费者 2：

import org.springframework.amqp.rabbit.annotation.RabbitListener; import org.springframework.stereotype.Component; @Component public class WorkConsumer2 { /** * 监听工作队列，消费消息（处理耗时较长） * @param message 消息内容 */ @RabbitListener(queues = "work.queue") public void consumeMessage(String message) { System.out.println("工作队列消费者2接收消息：" + message); // 模拟处理耗时：500毫秒 try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("工作队列消费者2处理完成：" + message); } }

步骤 4：配置消息确认和预取数量（优化负载均衡）

默认的轮询策略会忽略消费者的处理能力，导致处理慢的消费者堆积大量消息。我们可以通过配置prefetchCount（预取数量），让消费者一次只获取指定数量的消息，处理完再获取下一批，实现更合理的负载均衡。

在application.yml中添加配置：

spring: rabbitmq: host: localhost port: 5672 username: guest password: guest virtual-host: / listener: simple: acknowledge-mode: manual # 手动确认消息（默认是auto，自动确认） prefetch: 1 # 预取数量为1，即消费者一次只能处理一条消息，处理完再取

修改消费者代码，添加手动确认消息的逻辑（以消费者 1 为例，消费者 2 同理）：

import com.rabbitmq.client.Channel; import org.springframework.amqp.core.Message; import org.springframework.amqp.rabbit.annotation.RabbitListener; import org.springframework.stereotype.Component; import java.io.IOException; @Component public class WorkConsumer1 { /** * 监听工作队列，消费消息（手动确认） * @param message 消息内容 * @param channel 信道 * @param msg AMQP消息对象 */ @RabbitListener(queues = "work.queue") public void consumeMessage(String message, Channel channel, Message msg) throws IOException { try { System.out.println("工作队列消费者1接收消息：" + message); // 模拟处理耗时：100毫秒 Thread.sleep(100); System.out.println("工作队列消费者1处理完成：" + message); // 手动确认消息：第二个参数表示是否批量确认 channel.basicAck(msg.getMessageProperties().getDeliveryTag(), false); } catch (InterruptedException e) { e.printStackTrace(); // 处理失败时，拒绝消息并重新入队（根据业务需求调整） channel.basicNack(msg.getMessageProperties().getDeliveryTag(), false, true); } } }

步骤 5：测试代码

创建测试类，批量发送消息，观察多个消费者的消费情况：

import org.junit.jupiter.api.Test; import org.springframework.boot.test.context.SpringBootTest; import javax.annotation.Resource; @SpringBootTest public class WorkModeTest { @Resource private WorkProducer workProducer; @Test public void testSendBatchMessage() { // 批量发送10条消息 workProducer.sendBatchMessage(10); // 休眠10秒，确保消费者有时间处理所有消息 try { Thread.sleep(10000); } catch (InterruptedException e) { e.printStackTrace(); } } }

运行测试后，会发现消费者 1（处理快）会消费更多的消息，而消费者 2（处理慢）消费较少的消息，实现了基于处理能力的负载均衡。

3.3 场景分析

工作队列模式适用于单个队列有大量消息需要处理，且希望通过多个消费者提高处理效率的场景，典型应用场景包括：

任务分发：比如电商平台的订单处理，生产者将订单消息发送到队列，多个消费者同时处理订单（如库存扣减、支付确认、物流通知等）。
图片处理：用户上传图片后，需要对图片进行压缩、裁剪、水印等处理，生产者将图片信息发送到队列，多个消费者并行处理图片。
数据计算：大数据场景下的简单计算任务，生产者将计算任务发送到队列，多个消费者分布式计算，提高计算效率。
流量削峰：比如秒杀活动中，大量的下单请求发送到队列，多个消费者慢慢处理，避免系统被瞬间高流量冲垮。

关键优化点：

消息持久化：队列和消息都设置为持久化，避免 RabbitMQ 重启后消息丢失。
手动消息确认：确保消费者处理完消息后再确认，避免消息丢失。
预取数量配置：根据消费者的处理能力设置prefetchCount，实现负载均衡。
消费者限流：通过prefetchCount限制消费者的并发处理数量，防止消费者过载。

四、简单模式 vs 工作队列模式

为了更清晰地对比两种模式的差异，我们整理了如下表格：

特性	简单模式	工作队列模式
消费者数量	一个	多个
消息分发策略	单一消费者独占所有消息	轮询 / 基于预取的负载均衡
处理效率	低（单消费者）	高（多消费者并行处理）
适用场景	一对一简单通信	高并发任务处理、负载均衡
扩展性	差（无法横向扩展消费者）	好（可动态增加消费者）