RabbitMQ--消息顺序性

看本章之前强烈建议先去看博主的这篇博客

RabbitMQ--消费端单线程与多线程-CSDN博客

一、消息顺序性概念

消息顺序性是指消息在生产者发送的顺序 和消费者接收处理的顺序保持一致。

---

二、RabbitMQ 顺序性保证机制

情况	顺序保证情况	备注
单队列，单消费者	消息严格按发送顺序消费	最简单且唯一保证顺序的场景
单队列，多个消费者	无法保证全局顺序，但可以设置 QoS 保证消费者串行处理自己收到的消息	通过 basicQos(1) 保证每个消费者一次只处理一条消息，但整体队列消息按消费者分配，顺序不保证
消息确认和重发机制	如果未正确使用 ack，消息重发可能导致顺序乱	需开启手动确认，确保消息处理完毕后才 ack
消息重试与死信机制	可能导致消息顺序错乱	需要设计合理的重试策略和死信队列策略

---

三、顺序性的保证方式

1. 单队列单消费者

   • 保证消息完全顺序消费。适合严格顺序场景。

2. 消息确认机制

   • 使用手动确认 autoAck=false，处理完后再 basicAck，防止消息乱序重发。

3. QoS（basicQos）

   • 设置 basicQos(1)，保证消费者一次只处理一条消息，避免多条消息并发处理导致乱序。

4. 业务分区设计

   • 按某个字段（比如订单ID）分区到不同队列，保证分区内顺序。

---

四、原生 Java 示例

---

1. 依赖

<dependency>
  <groupId>com.rabbitmq</groupId>
  <artifactId>amqp-client</artifactId>
  <version>5.16.0</version>
</dependency>

---

2. 生产者代码

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

public class Producer {

    private static final String QUEUE_NAME = "order_queue";

    public static void main(String[] args) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");

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

            // 声明队列，持久化
            channel.queueDeclare(QUEUE_NAME, true, false, false, null);

            for (int i = 1; i <= 10; i++) {
                String message = "Order Message " + i;
                channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
                System.out.println("Sent: " + message);
                Thread.sleep(100);  // 模拟发送间隔
            }
        }
    }
}

---

3. 消费者代码（单个消费者，保证顺序）

import com.rabbitmq.client.*;

public class Consumer {

    private static final String QUEUE_NAME = "order_queue";

    public static void main(String[] args) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");

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

        // 声明队列
        channel.queueDeclare(QUEUE_NAME, true, false, false, null);

        // 设置每次只处理一条消息，避免乱序
        channel.basicQos(1);

        System.out.println("Waiting for messages...");

        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody());
            System.out.println("Received: " + message);

            try {
                // 模拟处理消息
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                // 手动确认消息
                channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
                System.out.println("Ack sent for: " + message);
            }
        };

        // 关闭自动确认，开启手动确认
        channel.basicConsume(QUEUE_NAME, false, deliverCallback, consumerTag -> {});
    }
}

---

4. 多消费者并发消费注意事项

• 多个消费者消费同一队列，消息分发是轮询，整体消息顺序无法保证。

• basicQos(1) 只保证单个消费者串行处理自己拿到的消息，但多个消费者间消息顺序无保证。

• 若需要严格顺序，需要保证单消费者消费或者分队列处理。

---

五、Spring Boot 示例

---

1. pom.xml 依赖

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

---

2. application.yml

spring:
  rabbitmq:
    host: localhost
    port: 5672
    username: guest
    password: guest
    listener:
      simple:
        # 每个消费者预取消息数量，类似 basicQos(1)
        prefetch: 1

---

3. RabbitMQ 配置类

import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitConfig {

    public static final String QUEUE_NAME = "order_queue";

    @Bean
    public Queue orderQueue() {
        return new Queue(QUEUE_NAME, true); // 持久化队列
    }
}

---

4. 生产者代码

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class Producer {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void sendMessages() throws InterruptedException {
        for (int i = 1; i <= 10; i++) {
            String message = "Order Message " + i;
            rabbitTemplate.convertAndSend(RabbitConfig.QUEUE_NAME, message);
            System.out.println("Sent: " + message);
            Thread.sleep(100);
        }
    }
}

---

5. 消费者代码

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class Consumer {

    @RabbitListener(queues = RabbitConfig.QUEUE_NAME)
    public void receiveMessage(String message) throws InterruptedException {
        System.out.println("Received: " + message);
        // 模拟消息处理时间，确保消息顺序
        Thread.sleep(500);
        System.out.println("Processed: " + message);
    }
}

---

6. 主启动类

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class RabbitOrderApplication implements CommandLineRunner {

    @Autowired
    private Producer producer;

    public static void main(String[] args) {
        SpringApplication.run(RabbitOrderApplication.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
        producer.sendMessages();
    }
}

---

六、总结

方面	说明
单队列单消费者	保证严格消息顺序，消息先进先出。
单队列多消费者	消息轮询分发，整体顺序无法保证；设置 basicQos(1) 保证单个消费者顺序处理自己的消息。
消息确认机制	手动 ack，避免消息未处理完成就确认导致顺序乱。
Spring Boot 配置	spring.rabbitmq.listener.simple.prefetch=1 控制每个消费者预取消息数。
业务设计建议	对于严格顺序场景，推荐单队列单消费者或消息分区+单消费者方案。

如果要严格保证消息顺序性：

1. 单队列单消费者

2. 多消费者分区顺序

当你只要求 "某一类业务 ID 下的顺序"一致，如订单、用户、设备号等，而不要求全局顺序时，这种方案很好。

不能做到全局顺序消费！

不同队列之间顺序是无法控制的

比如 order_1 和 order_5 属于不同分区，它们的处理时间会交叉，整体顺序就乱了。

多消费者分区顺序****代码样例

• 利用多个队列（分区），每个队列绑定一个消费者，保证队列内消息顺序；

• 生产者根据某个分区键（如订单ID哈希）选择发送到对应队列，保证同一个分区的消息顺序。

---

多消费者分区顺序消费示例（Spring Boot）

---

1. 项目结构与依赖

pom.xml 添加：

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

---

2. 配置类：定义多个队列与交换机绑定

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitConfig {

    public static final int PARTITION_COUNT = 3;

    @Bean
    public DirectExchange directExchange() {
        return new DirectExchange("order_exchange");
    }

    @Bean
    public Queue queue0() {
        return new Queue("order_queue_0", true);
    }

    @Bean
    public Queue queue1() {
        return new Queue("order_queue_1", true);
    }

    @Bean
    public Queue queue2() {
        return new Queue("order_queue_2", true);
    }

    @Bean
    public Binding binding0(Queue queue0, DirectExchange directExchange) {
        return BindingBuilder.bind(queue0).to(directExchange).with("partition_0");
    }

    @Bean
    public Binding binding1(Queue queue1, DirectExchange directExchange) {
        return BindingBuilder.bind(queue1).to(directExchange).with("partition_1");
    }

    @Bean
    public Binding binding2(Queue queue2, DirectExchange directExchange) {
        return BindingBuilder.bind(queue2).to(directExchange).with("partition_2");
    }
}

---

3. 生产者：根据订单ID哈希选择分区，发送到对应RoutingKey

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class Producer {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    private static final int PARTITION_COUNT = RabbitConfig.PARTITION_COUNT;

    public void sendOrder(String orderId, String message) {
        int partition = Math.abs(orderId.hashCode()) % PARTITION_COUNT;
        String routingKey = "partition_" + partition;
        rabbitTemplate.convertAndSend("order_exchange", routingKey, message);
        System.out.println("Sent to " + routingKey + ": " + message);
    }
}

---

4. 消费者：为每个队列配置单独消费者，保证分区顺序

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class Consumer {

    @RabbitListener(queues = "order_queue_0")
    public void receivePartition0(String message) {
        System.out.println("Partition 0 received: " + message);
        // 业务处理，保证队列内顺序
    }

    @RabbitListener(queues = "order_queue_1")
    public void receivePartition1(String message) {
        System.out.println("Partition 1 received: " + message);
    }

    @RabbitListener(queues = "order_queue_2")
    public void receivePartition2(String message) {
        System.out.println("Partition 2 received: " + message);
    }
}

---

5. 测试调用示例（主程序）

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class PartitionOrderApplication implements CommandLineRunner {

    @Autowired
    private Producer producer;

    public static void main(String[] args) {
        SpringApplication.run(PartitionOrderApplication.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
        // 发送多条订单消息，orderId不同分区
        for (int i = 0; i < 20; i++) {
            String orderId = "order" + i;
            String message = "Order message for " + orderId;
            producer.sendOrder(orderId, message);
            Thread.sleep(100);
        }
    }
}

---

6. 说明

• 消息根据订单ID哈希决定发送哪个队列

• 每个队列由单个消费者消费，保证该分区消息顺序

• 多个队列+多消费者，实现并发消费和分区顺序

🔁 顺序保证范围

粒度	保证情况
同一个 orderId	✅ 顺序消费（始终落在同一队列）
不同 orderId	❌ 不保证顺序（本来就不是要求）

---

✅ 结论

你这套方案：

• 👍 是 Spring Boot 下 RabbitMQ 顺序消费的推荐做法

• 👍 保证了"每个订单 ID 的消息顺序"

• 👍 可扩展，增加分区数提升并发能力