RocketMQ顺序消息

最新推荐文章于 2024-06-30 18:40:12 发布
最新推荐文章于 2024-06-30 18:40:12 发布
阅读量481 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/starcrm/article/details/106611176
版权

消息有序指的是一类消息消费时，能按照发送的顺序来消费。例如：一个订单产生了三条消息分别是订单创建、订单付款、订单完成。消费时要按照这个顺序消费才能有意义，但是同时订单之间是可以并行消费的。RocketMQ可以严格的保证消息有序。

顺序消息分为全局顺序消息与分区顺序消息，全局顺序是指某个Topic下的所有消息都要保证顺序；部分顺序消息只要保证每一组消息被顺序消费即可。

  • 全局顺序 对于指定的一个 Topic，所有消息按照严格的先入先出（FIFO）的顺序进行发布和消费。 适用场景：性能要求不高，所有的消息严格按照 FIFO 原则进行消息发布和消费的场景
  • 分区顺序 对于指定的一个 Topic，所有消息根据 sharding key 进行区块分区。 同一个分区内的消息按照严格的 FIFO 顺序进行发布和消费。 Sharding key 是顺序消息中用来区分不同分区的关键字段，和普通消息的 Key 是完全不同的概念。 适用场景：性能要求高，以 sharding key 作为分区字段，在同一个区块中严格的按照 FIFO 原则进行消息发布和消费的场景。

RocketMQ可以严格的保证消息有序。但这个顺序，不是全局顺序，只是分区（queue）顺序。要全局顺序只能一个分区。

非顺序的原因，是因为发送消息的时候，消息发送默认是会采用轮询的方式发送到不通的queue（分区）。而消费端消费的时候，是会分配到多个queue的，多个queue是同时拉取提交消费。如果是轮询的生产者，加上同时的多线程读取，自然不能保证顺序。

如果把一个分区顺序投放在同一个分区里面，RocketMQ的确是能保证FIFO的。那么要做到顺序消息，应该怎么实现呢——把消息确保投递到同一条queue。

比如一个订单，根据同一个id，把创建-扣款（买家）-付款（给商家）的三条消息，按顺序推入一个队列，那消费的时候也是顺序执行的。

关键代码，按订单ID放入同一分区：

producer.send(msg, new MessageQueueSelector() {
                @Override
                public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {
                    Long id = (Long) arg;  //根据订单id选择发送queue
                    long index = id % mqs.size();
                    return mqs.get((int) index);
                }
            }, orderList.get(i).getOrderId());//订单id

 

完整的生产者

package com.xin.rocketmq.demo.testrun;

import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.MessageQueueSelector;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.common.message.MessageQueue;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * Producer，发送顺序消息
 */
public class Producer {

    public static void main(String[] args) throws Exception {
        DefaultMQProducer producer = new DefaultMQProducer("please_rename_unique_group_name");

        producer.setNamesrvAddr("192.168.10.11:9876");

        producer.start();

        String[] tags = new String[]{"TagA", "TagC", "TagD"};

        // 订单列表
        List<OrderStep> orderList = new Producer().buildOrders();

        Date date = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateStr = sdf.format(date);
        for (int i = 0; i < 10; i++) {
            // 加个时间前缀
            String body = dateStr + " Hello RocketMQ " + orderList.get(i);
            Message msg = new Message("TopicTest", tags[i % tags.length], "KEY" + i, body.getBytes());

            SendResult sendResult = producer.send(msg, new MessageQueueSelector() {
                @Override
                public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {
                    Long id = (Long) arg;  //根据订单id选择发送queue
                    long index = id % mqs.size();
                    return mqs.get((int) index);
                }
            }, orderList.get(i).getOrderId());//订单id

            System.out.println(String.format("SendResult status:%s, queueId:%d, body:%s",
                    sendResult.getSendStatus(),
                    sendResult.getMessageQueue().getQueueId(),
                    body));
        }

        producer.shutdown();
    }

    /**
     * 订单的步骤
     */
    private static class OrderStep {
        private long orderId;
        private String desc;

        public long getOrderId() {
            return orderId;
        }

        public void setOrderId(long orderId) {
            this.orderId = orderId;
        }

        public String getDesc() {
            return desc;
        }

        public void setDesc(String desc) {
            this.desc = desc;
        }

        @Override
        public String toString() {
            return "OrderStep{" +
                    "orderId=" + orderId +
                    ", desc='" + desc + '\'' +
                    '}';
        }
    }

    /**
     * 生成模拟订单数据
     */
    private List<OrderStep> buildOrders() {
        List<OrderStep> orderList = new ArrayList<OrderStep>();

        OrderStep orderDemo = new OrderStep();
        orderDemo.setOrderId(15103111039L);
        orderDemo.setDesc("创建");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(15103111065L);
        orderDemo.setDesc("创建");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(15103111039L);
        orderDemo.setDesc("付款");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(15103117235L);
        orderDemo.setDesc("创建");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(15103111065L);
        orderDemo.setDesc("付款");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(15103117235L);
        orderDemo.setDesc("付款");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(15103111065L);
        orderDemo.setDesc("完成");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(15103111039L);
        orderDemo.setDesc("推送");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(15103117235L);
        orderDemo.setDesc("完成");
        orderList.add(orderDemo);

        orderDemo = new OrderStep();
        orderDemo.setOrderId(15103111039L);
        orderDemo.setDesc("完成");
        orderList.add(orderDemo);

        return orderList;
    }
}

结果把同一个id放在一个分区了

SendResult status:SEND_OK, queueId:3, body:2020-06-07 14:28:49 Hello RocketMQ OrderStep{orderId=15103111039, desc='创建'}
SendResult status:SEND_OK, queueId:1, body:2020-06-07 14:28:49 Hello RocketMQ OrderStep{orderId=15103111065, desc='创建'}
SendResult status:SEND_OK, queueId:3, body:2020-06-07 14:28:49 Hello RocketMQ OrderStep{orderId=15103111039, desc='付款'}
SendResult status:SEND_OK, queueId:3, body:2020-06-07 14:28:49 Hello RocketMQ OrderStep{orderId=15103117235, desc='创建'}
SendResult status:SEND_OK, queueId:1, body:2020-06-07 14:28:49 Hello RocketMQ OrderStep{orderId=15103111065, desc='付款'}
SendResult status:SEND_OK, queueId:3, body:2020-06-07 14:28:49 Hello RocketMQ OrderStep{orderId=15103117235, desc='付款'}
SendResult status:SEND_OK, queueId:1, body:2020-06-07 14:28:49 Hello RocketMQ OrderStep{orderId=15103111065, desc='完成'}
SendResult status:SEND_OK, queueId:3, body:2020-06-07 14:28:49 Hello RocketMQ OrderStep{orderId=15103111039, desc='推送'}
SendResult status:SEND_OK, queueId:3, body:2020-06-07 14:28:49 Hello RocketMQ OrderStep{orderId=15103117235, desc='完成'}
SendResult status:SEND_OK, queueId:3, body:2020-06-07 14:28:49 Hello RocketMQ OrderStep{orderId=15103111039, desc='完成'}

消费者

package com.xin.rocketmq.demo.testrun;

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyContext;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerOrderly;
import org.apache.rocketmq.common.consumer.ConsumeFromWhere;
import org.apache.rocketmq.common.message.MessageExt;

import java.util.List;
import java.util.Random;
import java.util.concurrent.TimeUnit;

/**
 * 顺序消息消费，带事务方式（应用可控制Offset什么时候提交）
 */
public class ConsumerInOrder {

    public static void main(String[] args) throws Exception {
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("please_rename_unique_group_name_3");
        consumer.setNamesrvAddr("192.168.10.11:9876");
        /**
         * 设置Consumer第一次启动是从队列头部开始消费还是队列尾部开始消费<br>
         * 如果非第一次启动，那么按照上次消费的位置继续消费
         */
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);

        consumer.subscribe("TopicTest", "TagA || TagC || TagD");

        consumer.registerMessageListener(new MessageListenerOrderly() {

            Random random = new Random();

            @Override
            public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
                context.setAutoCommit(true);
                for (MessageExt msg : msgs) {
                    // 可以看到每个queue有唯一的consume线程来消费, 订单对每个queue(分区)有序
                    System.out.println("consumeThread=" + Thread.currentThread().getName() + "queueId=" + msg.getQueueId() + ", content:" + new String(msg.getBody()));
                }

                try {
                    //模拟业务逻辑处理中...
                    TimeUnit.SECONDS.sleep(random.nextInt(10));
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return ConsumeOrderlyStatus.SUCCESS;
            }
        });

        consumer.start();

        System.out.println("Consumer Started.");
    }
}

消费也是分区的顺序消费

consumeThread=ConsumeMessageThread_1queueId=1, content:2020-06-07 14:28:49 Hello RocketMQ OrderStep{orderId=15103111065, desc='创建'}
consumeThread=ConsumeMessageThread_2queueId=3, content:2020-06-07 14:28:49 Hello RocketMQ OrderStep{orderId=15103111039, desc='创建'}
consumeThread=ConsumeMessageThread_2queueId=3, content:2020-06-07 14:28:49 Hello RocketMQ OrderStep{orderId=15103111039, desc='付款'}
consumeThread=ConsumeMessageThread_1queueId=1, content:2020-06-07 14:28:49 Hello RocketMQ OrderStep{orderId=15103111065, desc='付款'}
consumeThread=ConsumeMessageThread_2queueId=3, content:2020-06-07 14:28:49 Hello RocketMQ OrderStep{orderId=15103117235, desc='创建'}
consumeThread=ConsumeMessageThread_1queueId=1, content:2020-06-07 14:28:49 Hello RocketMQ OrderStep{orderId=15103111065, desc='完成'}
consumeThread=ConsumeMessageThread_2queueId=3, content:2020-06-07 14:28:49 Hello RocketMQ OrderStep{orderId=15103117235, desc='付款'}
consumeThread=ConsumeMessageThread_2queueId=3, content:2020-06-07 14:28:49 Hello RocketMQ OrderStep{orderId=15103111039, desc='推送'}
consumeThread=ConsumeMessageThread_2queueId=3, content:2020-06-07 14:28:49 Hello RocketMQ OrderStep{orderId=15103117235, desc='完成'}
consumeThread=ConsumeMessageThread_2queueId=3, content:2020-06-07 14:28:49 Hello RocketMQ OrderStep{orderId=15103111039, desc='完成'}

 消费者将锁定每个消息队列，以确保他们被逐个消费，虽然这将会导致性能下降，但是当你关心消息顺序的时候会很有用。我们不建议抛出异常，你可以返回 ConsumeOrderlyStatus.SUSPEND_CURRENT_QUEUE_A_MOMENT 作为替代。

昕友软件
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
自顶向下学习 RocketMQ（四）：顺序消息
m0_38017860的博客
12-21 1311
顺序消息顺序消息是消息队列 RocketMQ 提供的一种对消息发送和消费顺序有严格要求的消息。对于一个指定的 Topic，消息严格按照先进先出（FIFO）的原则进行消息发布和消费，即先发布的消息先消费，后发布的消息后消费。顺序消息分为 分区顺序消息 和 全局顺序消息分区顺序消息“分区顺序 对于指定的一个 Topic，所有消息根据 sharding key 进行区块分区。同一个分区内的消息按照严格的 FIFO 顺序进行发布和消费。Sharding key 是顺序消息中用来区分不同分区的关键字段，和普通消息的
RocketMQ分布式消息队列
09-11
顺序消息：RocketMQ提供的一种按照顺序进行发布和消费的消息类型，分为全局顺序消息和分区顺序消息。 全局顺序消息：对于指定的一个Topic，所有消息按照严格的先入先出（FIFO）的顺序进行发布和消费。 分区顺序...
python总线 rabbitmq_收发顺序消息_开源 Python SDK 接入说明_TCP 协议（社区版）_SDK 参考_消息队列 RocketMQ 版 - 阿里云...
weixin_39716921的博客
12-11 420
顺序消息(FIFO 消息)是阿里云 RocketMQ 提供的一种严格按照顺序来发布和消费的消息类型。本文提供使用 TCP 协议下的开源 Python SDK 收发顺序消息的示例代码供您参考。顺序消息分为两类：全局顺序：对于指定的一个 Topic，所有消息按照严格的先入先出(First In First Out，简称 FIFO)的顺序进行发布和消费。分区顺序：对于指定的一个 Topic，所有消息根据...
基于RocketMQ消息中间件的顺序消息的设计
huxian1234的专栏
04-24 274
胡弦，视频号2023年度优秀创作者，互联网大厂P8技术专家，Spring Cloud Alibaba微服务架构实战派(上下册)和RocketMQ消息中间件实战派(上下册)的作者，资深架构师，技术负责人，极客时间训练营讲师，四维口袋KVP最具价值技术专家，技术领域专家团成员，2021电子工业出版社年度优秀作者，获得2023电子工业出版技术成长领路人称号，荣获2024年电子工业出版社博文视点20周年荣誉专家称号。
RocketMQ（九）RocketMQ顺序消息
weixiaohuai的博客
03-29 6480
目录 一、什么是顺序消息？ 二、顺序消息的原理 三、全局顺序消息 四、局部顺序消息 五、顺序消息缺陷 一、什么是顺序消息？ 消息有序指的是，消费者端消费消息时，需按照消息的发送顺序来消费，即先发送的消息，需要先消费(FIFO)。 举个容易理解的例子：通常创建订单后，会经历一系列的操作：【订单创建 -> 订单支付 -> 订单发货 -> 订单配送 -> 订单完成】。在创建完订单后，会发送五条消息到MQ Broker中，消费的时候要按照【订单创建 -> 订单支付 -&
RocketMQ的顺序消息（顺序消费）
热门推荐
终生学习践行者
10-29 4万+
简单介绍了消息有序性的概念，以及RocketMQ如何实现消息的顺序消费。
RocketMQ顺序消息机制源码分析~
m0_71777195的博客
08-24 182
RocketMQ为了保证消息的顺序性，分别从Producer和Consumer都有着相应的设计~Producer方面，为保证顺序消息，可自定义MessageQueueSelector来选择队列。例: orderId % msgQueueSize，从而可保证同一个orderId的相关消息，会被发送到同一个队列里。Consumer方面，在整体设计上用了三把锁，来保证消息的顺序消费。定时任务周期性对消费者所属队列加锁消费时对消息队列加锁消息真正被消费前，对processQueue加消费锁。
rocketmq消息队列
08-05
4. 顺序消息：对于对消息顺序有严格要求的应用，RocketMQ提供了一种保证消息全局有序的功能。 5. 分布式事务：RocketMQ支持分布式事务，使得跨多个服务的事务操作成为可能。 6. 延迟与定时消息：用户可以设置消息的...
rocketmq消息中间件
05-03
- **CommitLog**：存储原始消息，按照顺序写入，提供高效读写。 - **Message Queue**：逻辑上的队列，对应消费者订阅的Topic下的分区，提供消息的寻址和并发消费能力。 5. **特性** - **高可用**：通过主备切换...
rocketmq消息中间件.zip
12-08
- **消息顺序**：提供严格的消息顺序保证，适用于金融交易等业务。 - **延迟与定时消息**：支持消息的定时和延时发送，满足不同业务需求。 - **事务消息**：提供分布式事务解决方案，确保事务的一致性。 - **...
springboot1.5.10.RELEASE集成rocketmq4.3.1消息服务demo，多个消费者多监听
08-03
每个消费者组内部的消息处理是顺序的，但不同消费者组之间是并发的。 通过以上步骤，你已经成功地在SpringBoot 1.5.10.RELEASE项目中集成了RocketMQ 4.3.1，并实现了多个消费者对同一主题的多监听。这个简单的示例...
rocketmq保证消息的顺序性
weixin_42161936的博客
04-11 1149
主要介绍rocketmq顺序消息的原理，以及怎么使用GO发送分区顺序消息
详解RocketMQ 顺序消费机制
华为云官方博客
05-30 1075
顺序消息是指对于一个指定的 Topic ，消息严格按照先进先出（FIFO）的原则进行消息发布和消费，即先发布的消息先消费，后发布的消息后消费。
RocketMQ-如何保证顺序消息
m0_71777195的博客
07-30 2033
实际开发中会有以下场景，需要保证一组消息的生产顺序与消费顺序相同，例如那么在 RocketMQ 中该如何保证消息的顺序呢？
RocketMQ 顺序消息和事务消息及其原理
最新发布
STRANGE-P 的博客
06-30 1094
使用消息中间件时，首先要了解各类型mq消息中间件的优势和劣势，根据自己项目的实际情况，结合各消息中间件特性，取长避短。本篇博文讲解了RocketMQ 的两大重要特性：顺序消息、事务消息。
RocketMq实现顺序消息
wanghl_的博客
01-03 664
由于前面讲过，一个主题中可能设置多个队列，消息可能被发往不同队列，以至于消费消息时，发现消息并不是按照顺序被消费的。但是很多时候，我们希望消息可以保持顺序消费，以下是学习过程中探索的方法。日后还会一直丰富。
阿里云RocketMQ
Hbger的博客
09-21 3452
阿里云RocketMQ原生API是通过ONSFactory工厂来创建消费者和生产者，创建之前需要通过Properties来指定一些配置信息 阿里云RocketMQ，提供了一些Bean用于集成至Spring容器中：（ProducerBean、ConsumerBean），（OrderProducerBean、OrderConsumerBean），TransactionProducerBean，我们只需配置初始化方法以及销毁方法，就能跟随Spring生命周期启动和销毁生产者和消费者 消息存储机制： 市面上消息中
RocketMQ：顺序消息与高可用设计详解
首先，我们了解到RocketMQ对顺序消息的支持非常重要。在分布式场景下，确保消息的消费顺序可以通过消息发送至同一MQServer来实现。生产者会先发送一条消息（例如M1）到服务器，等待其确认成功后再发送下一条消息（M2...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值