RocketMQ 发送顺序消息样例

最新推荐文章于 2024-06-03 17:26:16 发布
最新推荐文章于 2024-06-03 17:26:16 发布
阅读量189 收藏
点赞数
分类专栏： RocketMQ 文章标签： rocketmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rzpy_qifengxiaoyue/article/details/109719358
版权

消息有序指的是可以按照消息的发送顺序来消费(FIFO)。RocketMQ可以严格的保证消息有序，可以分为分区有序或者全局有序。

顺序消费的原理解析，在默认的情况下消息发送会采取Round Robin轮询方式把消息发送到不同的queue(分区队列)；而消费消息的时候从多个queue上拉取消息，这种情况发送和消费是不能保证顺序。但是如果控制发送的顺序消息只依次发送到同一个queue中，消费的时候只从这个queue上依次拉取，则就保证了顺序。当发送和消费参与的queue只有一个，则是全局有序；如果多个queue参与，则为分区有序，即相对每个queue，消息都是有序的。

下面用订单进行分区有序的示例。一个订单的顺序流程是：创建、付款、推送、完成。订单号相同的消息会被先后发送到同一个队列中，消费时，同一个OrderId获取到的肯定是同一个队列。

1. 顺序消息生产

package org.apache.rocketmq.example.order2;

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("127.0.0.1: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;
   }
}

SendResult status:SEND_OK, queueId:1, body:2020-11-16 14:28:26 Hello RocketMQ OrderStep{orderId=15103111039, desc='创建'}
SendResult status:SEND_OK, queueId:0, body:2020-11-16 14:28:26 Hello RocketMQ OrderStep{orderId=15103111065, desc='创建'}
SendResult status:SEND_OK, queueId:1, body:2020-11-16 14:28:26 Hello RocketMQ OrderStep{orderId=15103111039, desc='付款'}
SendResult status:SEND_OK, queueId:2, body:2020-11-16 14:28:26 Hello RocketMQ OrderStep{orderId=15103117235, desc='创建'}
SendResult status:SEND_OK, queueId:0, body:2020-11-16 14:28:26 Hello RocketMQ OrderStep{orderId=15103111065, desc='付款'}
SendResult status:SEND_OK, queueId:2, body:2020-11-16 14:28:26 Hello RocketMQ OrderStep{orderId=15103117235, desc='付款'}
SendResult status:SEND_OK, queueId:0, body:2020-11-16 14:28:26 Hello RocketMQ OrderStep{orderId=15103111065, desc='完成'}
SendResult status:SEND_OK, queueId:1, body:2020-11-16 14:28:26 Hello RocketMQ OrderStep{orderId=15103111039, desc='推送'}
SendResult status:SEND_OK, queueId:2, body:2020-11-16 14:28:26 Hello RocketMQ OrderStep{orderId=15103117235, desc='完成'}
SendResult status:SEND_OK, queueId:1, body:2020-11-16 14:28:26 Hello RocketMQ OrderStep{orderId=15103111039, desc='完成'}

2. 顺序消费消息

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyContext;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerConcurrently;
import org.apache.rocketmq.common.message.MessageExt;
import java.util.List;

package org.apache.rocketmq.example.order2;

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("127.0.0.1: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_20,queueId=0, content:2020-11-16 14:28:26 Hello RocketMQ OrderStep{orderId=15103111065, desc='创建'}
consumeThread=ConsumeMessageThread_20,queueId=0, content:2020-11-16 14:28:26 Hello RocketMQ OrderStep{orderId=15103111065, desc='付款'}
consumeThread=ConsumeMessageThread_20,queueId=0, content:2020-11-16 14:28:26 Hello RocketMQ OrderStep{orderId=15103111065, desc='完成'}
consumeThread=ConsumeMessageThread_20,queueId=2, content:2020-11-16 14:28:26 Hello RocketMQ OrderStep{orderId=15103117235, desc='创建'}
consumeThread=ConsumeMessageThread_20,queueId=2, content:2020-11-16 14:28:26 Hello RocketMQ OrderStep{orderId=15103117235, desc='付款'}
consumeThread=ConsumeMessageThread_20,queueId=2, content:2020-11-16 14:28:26 Hello RocketMQ OrderStep{orderId=15103117235, desc='完成'}
consumeThread=ConsumeMessageThread_3,queueId=1, content:2020-11-16 14:28:26 Hello RocketMQ OrderStep{orderId=15103111039, desc='创建'}
consumeThread=ConsumeMessageThread_3,queueId=1, content:2020-11-16 14:28:26 Hello RocketMQ OrderStep{orderId=15103111039, desc='付款'}
consumeThread=ConsumeMessageThread_3,queueId=1, content:2020-11-16 14:28:26 Hello RocketMQ OrderStep{orderId=15103111039, desc='推送'}
consumeThread=ConsumeMessageThread_3,queueId=1, content:2020-11-16 14:28:26 Hello RocketMQ OrderStep{orderId=15103111039, desc='完成'}
四月丶丶
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RocketMQ——Producer篇：发送顺序消息
meilong_whpu的专栏
08-09 2796
顺序消息主要是指局部顺序，即生产者通过将某一类消息发送至同一个队列来实现。与发生普通消息相比，在发送顺序消息时要对同一类型的消息选择同一个队列，即同一个MessageQueue对象。 目前RocketMQ定义了选择MessageQueue对象的接口MessageQueueSelector，里面有方法select(final List mqs, final Message msg, final Ob
RocketMQ顺序消息的实现实例
qq_16570607的博客
07-09 483
消费状态 package org.apache.rocketmq.client.consumer.listener; public enum ConsumeOrderlyStatus { /** * Success consumption */ SUCCESS, /** * Suspend current queue a moment * 不能跳过消息，等待一下 */ SUSPEND_CURRENT_QUEUE_A_MO
RocketMq 顺序消费、分区消息、延迟发送消息、Topic、tag分类 实战 （生产者） （二）
lixiaobai_boke的博客
03-20 407
RocketMq 顺序消费、分区消息、延迟发送消息、Topic、tag分类 实战 （生产者） （二）
RocketMQ发送顺序消息原理与代码demo
最新发布
m0_51681531的博客
06-03 882
RocketMQ发送顺序消息原理与代码demo
RocketMQ：顺序消息
yanyf的博客
12-31 261
消息有序指的是可以按照消息的发送顺序来消费。rockermq可以严格的保证消息有序，可以分为分区有序或者全部有序顺序消费的原理解析，在默认的情况下消息发送会采取round robin轮询方式把消息发送到不同的queue（分区队列）； 而消费消息的时候从多个queue上拉取消息，这种情况发送和消费是不能保证顺序。但是如果控制发送的顺序消息只一次发送 到同一个queue中，消费的时候只从这...
消息中间件—RocketMQ消息发送
01-27
本文来自于jianshu，文章介绍了RocketMQ网络架构图以及RocketMQ发送普通消息的全流程解读等相关内容。摘要：使用客户端发送一条消息很Easy，在这背后RocketMQ完成了怎么样的操作呢？大道至简，消息队列可以简单概括...
RocketMq事务消息发送代码流程详解
08-18
RocketMq事务消息发送代码流程详解 RocketMq是一种流行的开源消息队列系统，事务消息是其核心功能之一。事务消息发送代码流程详解是指在RocketMq中实现事务消息发送的整个过程。下面我们将详细介绍RocketMq事务消息...
RocketMQ：发送消息与接收实例
08-28
RockeMQ 服务器安装包、控制台代码、消息发送接收代码【同步发送 异步发送 单向发送 顺序发送】
封装RocketMq相关消息请求接口
10-16
jar包中封装了RocketMq中的相关消息请求，具体使用方法可看代码中，如有疑问可留言交流！！
RocetMQ发送顺序消息的所有方法以及代码示例
catdrinkcola的博客
01-11 1421
帮助读者学习使用RocketMQ发送顺序消息，本文总结出了使用RocketMQ发送顺序消息的所有方法。
RocketMQ 控制消息分区
qq_26919721的博客
11-03 968
this.producer = ONSFactory.createProducer(properties); producer.start(); Message mqMessage = new Message(); //hashKey相同会路由到相同的分区中 mqMessage.setShardingKey(String.valueOf(hashId));
RocketMQ-初体验RocketMQ(07)-使用API操作RocketMQ_顺序消息 ordermessage
小工匠
11-10 9431
文章目录顺序消息的概念顺序消费的原理消费状态演示ProducerConsumer 顺序消息的概念 消息有序指的是可以按照消息的发送顺序来消费(FIFO)。 RocketMQ可以严格的保证消息有序，可以分为分区有序或者全局有序。 顺序消费的原理 在默认的情况下消息发送会采取Round Robin轮询方式把消息发送到不同的queue(分区队列)； 而消费消息的时候从多个queue上拉取消息，这种...
RocketMQ 顺序消息
qq_32092237的博客
10-09 533
什么是消息有序？ 答：按照消息的发送的顺序来消费，比如生产者按序发送的A、B消息，那么消费者必须先消费A再消费B；这个顺序只能是分区顺序不是全局顺序，除非全局只有1个分区； 消息顺序问题的原因： 答：逻辑上的TOPIC分布在多个物理Broker上，这时Producer往Topic发送数据，默认使用轮询策略，发送不同的消息到不同的Broker的分区中上，由于中间传输网络、Broker写入效率等原因，无法保障Producer先发送的数据，一定在Borker中的先写入的。 对于Consumer而已，他的消费队列是
如何保证消息的顺序性？
weixin_45870899的博客
04-07 181
我举个例子，你在 mysql 里增删改一条数据，对应出来了增删改 3 条 日志，接着这三条发送到 MQ 里面，再消费出来依次执行，起码得保证人家是按照顺序来的吧？不然本来是：增加、修改、删除；你楞是换了顺序给执行成删除、修改、增加，不全错了么。 本来这个数据同步过来，应该最后这个数据被删除了；结果你搞错了这个顺序，最后这个数据保留下来了，数据同步就出错了。 先看看顺序会错乱的俩场景： Rabb...
RocketMQ(2) -- RocketMQ的基本概念
姜皓的博客
04-24 4595
RocketMQ的基本概念
RocketMQ的消息发送方式
凡是过往，皆为序章
10-17 7528
目录 同步发送 异步发送 单向发送 总结 同步发送 简单来说，同步发送就是指 producer 发送消息后，会在接收到 broker 响应后才继续发下一条消息的通信方式。 由于这种同步发送的方式确保了消息的可靠性，同时也能及时得到消息发送的结果，故而适合一些发送比较重要的消息场景，比如说重要的通知邮件、营销短信等等。在实际应用中，这种同步发送的方式还是用得比较多的。 异步...
RocketMQ详解（一）：RocketMQ架构详解
欢迎来到Jimmy的博客
08-20 2465
MQ的三大特性：1、异步解耦上游系统对下游系统的调用如果是同步调用，则会大大降低系统的吞吐量与并发度，且系统间耦合度太高。而异步调用则会解决这些问题，一般做法就是，在两层间添加一个MQ层。2、流量削峰MQ可以将系统的超量请求暂存其中，以便系统后期可以慢慢进行处理，从而避免了请求的丢失或系统被压垮。3、数据收集分布式系统会产生海量级别的数据流，比如业务日志，监控数据，用户行为等。针对这些数据流进行实时或批量采集汇总，然后对这些数据流进行大数据分析，MQ完成此类数据收集是最好的选择。
RocketMQ 消息结构和消息类型
jiaomubai的博客
05-27 3044
生产者 Producer 概述和消息结构与消息类型
RocketMQ(分布式消息队列)
D1842501760的博客
02-25 4914
超级好用
分布式开放消息系统(RocketMQ)的原理与实践.docx
09-14
RocketMQ通过优化消息发送策略、多副本备份、确认机制以及负载均衡等方式，解决了分布式消息系统中的顺序和重复问题，使得其在高并发、大规模分布式应用中表现出色。对于初次接触RocketMQ的读者，建议先阅读附录部分...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值