RocketMQ详解(7)——顺序消费

最新推荐文章于 2024-08-02 19:30:00 发布
最新推荐文章于 2024-08-02 19:30:00 发布
阅读量1.3w 收藏 52
点赞数 10
分类专栏： RocketMQ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_34452850/article/details/82664799
版权

RocketMQ详解(7)——顺序消费

一. 顺序消费原理

  1. 消息的有序性是指消息的消费顺序能够严格保存与消息的发送顺序一致。例如，一个订单产生了3条消息，分别是订单创建、订单付款和订单完成。在消息消费时，同一条订单要严格按照这个顺序进行消费，否则业务会发生混乱。同时，不同订单之间的消息又是可以并发消费的，比如可以先执行第三个订单的付款，再执行第二个订单的创建。
  2. RocketMQ采用了局部顺序一致性的机制，实现了单个队列中的消息严格有序。也就是说，如果想要保证顺序消费，必须将一组消息发送到同一个队列中，然后再由消费者进行注意消费。
  3. RocketMQ推荐的顺序消费解决方案是：安装业务划分不同的队列，然后将需要顺序消费的消息发往同一队列中即可，不同业务之间的消息仍采用并发消费。这种方式在满足顺序消费的同时提高了消息的处理速度，在一定程度上避免了消息堆积问题。

二. 生产端实现

  1. 生产端要实现顺序消费，需要借助于MessageQueueSelector接口。

    public interface MessageQueueSelector {
   MessageQueue select(final List<MessageQueue> mqs, final Message msg, final Object arg);
}

    MessageQueueSelector接口定义了一个select方法，具体参数含义为：

    • mqs：该Topic下所有可选的MessageQueue
    • msg：待发送的消息
    • arg：发送消息时传递的参数

    可以实现MessageQueueSelector接口，在select方法中自定义选择哪个MessageQueue。然后调用

    public SendResult send(Message msg, MessageQueueSelector selector, Object arg)
       throws MQClientException, RemotingException, MQBrokerException, InterruptedException {
       return this.defaultMQProducerImpl.send(msg, selector, arg);
   }

    这个方法发送消息，其中arg参数会传到select方法中。

  2. 示例代码

    本例模拟订单消息的发送。共有3个订单，每个订单都包含下单、支付、结算、完成四个流程，对应4条消息。同一个订单的消息要求严格按照顺序消费，不同订单的消息可以并发执行。

    首先实现MessageQueueSelector接口，定制MessageQueue选择策略：

    package william.rmq.producer.order;

import org.apache.rocketmq.client.producer.MessageQueueSelector;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.common.message.MessageQueue;
import java.util.List;

/**
* @Auther: ZhangShenao
* @Date: 2018/9/11 17:36
* @Description: 自定义MessageQueueSelector，根据发送消息时传递的参数，选择指定的MessageQueue
*/
public class OrderMessageQueueSelector implements MessageQueueSelector{
   @Override
   public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {
       //选择以参数arg为索引的MessageQueue
       Integer id = (Integer) arg;
       int index = id % mqs.size();
       return mqs.get(index);
   }
}

    在select方法中，根据传入的arg参数决定目标MessageQueue的索引。

    下面实现发送消息逻辑：

    package william.rmq.producer.order;

import lombok.extern.slf4j.Slf4j;
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.common.RemotingHelper;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import william.rmq.common.constant.RocketMQConstant;
import william.rmq.producer.common.CommonSendCallback;
import javax.annotation.PostConstruct;

/**
* @Auther: ZhangShenao
* @Date: 2018/9/11 17:32
* @Description:顺序消息生产端
*/
@Slf4j
@Service
public class OrderMessageProducer {
   @Value("${spring.rocketmq.namesrvAddr}")
   private String namesrvAddr;

   private static final DefaultMQProducer producer = new DefaultMQProducer("OrderProducer");

   private static final String[] ORDER_MESSAGES = {"下单","结算","支付","完成"};


   @PostConstruct
   public void sendMessage() {
       try {
           //设置namesrv
           producer.setNamesrvAddr(namesrvAddr);

           //启动Producer
           producer.start();

           System.err.println("Order Message Producer Start...");

           //创建3组消息，每组消息发往同一个Queue，保证消息的局部有序性
           String tags = "Tags";

           OrderMessageQueueSelector orderMessageQueueSelector = new OrderMessageQueueSelector();

           //注：要实现顺序消费，必须同步发送消息
           for (int i = 0;i < 3;i++){
               String orderId = "" + (i + 1);
               for (int j = 0,size = ORDER_MESSAGES.length;j < size;j++){
                   String message = "Order-" + orderId + "-" + ORDER_MESSAGES[j];
                   String keys = message;
                   byte[] messageBody = message.getBytes(RemotingHelper.DEFAULT_CHARSET);
                   Message mqMsg = new Message(RocketMQConstant.TEST_TOPIC_NAME, tags, keys, messageBody);
                   producer.send(mqMsg, orderMessageQueueSelector,i);
               }
           }


       } catch (Exception e) {
           log.error("Message Producer: Send Message Error ", e);
       }

   }
}

    使用DefaultMQProducer的send()方法，指定MessageQueueSelector和参数，Broker将会将逻辑上需要保证顺序性的消息发往同一队列。

    注：想要实现顺序消费，发送方式必须为同步发送，异步发送无法保证消息的发送顺序！

三. 消费端实现

  1. 消费端想要实现顺序消费，只要设置监听器实现MessageListenerOrderly接口即可。

  2. 示例代码

    首先自定义MessageListenerOrderly接口实现类，实现顺序消费：

    package william.rmq.consumer.order;

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.message.MessageExt;
import org.apache.rocketmq.remoting.common.RemotingHelper;
import org.springframework.util.CollectionUtils;
import java.util.List;

/**
* @Auther: ZhangShenao
* @Date: 2018/9/11 17:53
* @Description:顺序消息监听器
*/
public class OrderMessageListener implements MessageListenerOrderly{
   @Override
   public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
       if (CollectionUtils.isEmpty(msgs)){
           return ConsumeOrderlyStatus.SUCCESS;
       }
       //设置自动提交
       context.setAutoCommit(true);
       msgs.stream()
               .forEach(msg -> {
                   try {
                       String messageBody = new String(msg.getBody(), RemotingHelper.DEFAULT_CHARSET);
                       System.err.println("Handle Order Message: messageId: " + msg.getMsgId() + ",topic: " + msg.getTopic() + ",tags: "
                               + msg.getTags() + ",keys: " + msg.getKeys() + ",messageBody: " + messageBody);
                   } catch (Exception e) {
                       throw new RuntimeException(e);
                   }
               });
       return ConsumeOrderlyStatus.SUCCESS;
   }
}

    下面就是消费逻辑：

    package william.rmq.consumer.order;

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.common.consumer.ConsumeFromWhere;
import org.apache.rocketmq.common.protocol.heartbeat.MessageModel;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import william.rmq.common.constant.RocketMQConstant;

import javax.annotation.PostConstruct;

/**
* @Auther: ZhangShenao
* @Date: 2018/9/11 17:53
* @Description:顺序消息的消费者
*/
@Service
public class OrderMessageConsumer {
   @Value("${spring.rocketmq.namesrvAddr}")
   private String namesrvAddr;

   private final DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("DefaultConsumer");

   @PostConstruct
   public void start() {
       try {
           //设置namesrv地址
           consumer.setNamesrvAddr(namesrvAddr);

           //从消息队列头部开始消费
           consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);

           //集群消费模式
           consumer.setMessageModel(MessageModel.CLUSTERING);

           //订阅主题
           consumer.subscribe(RocketMQConstant.TEST_TOPIC_NAME, "*");

           //注册消息监听器，这里因为要实现顺序消费，所以必须注册MessageListenerOrderly
           consumer.registerMessageListener(new OrderMessageListener());

           //启动消费端
           consumer.start();

           System.err.println("Order Message Consumer Start...");
       } catch (Exception e) {
           throw new RuntimeException(e);
       }

   }
}

    先启动消费端工程，在启动生产端工程，可以看到消费端的控制台输出如下：

    Handle Order Message: messageId: 0A0E089B386F18B4AAC23B99C8440000,topic: DefaultCluster,tags: Tags,keys: Order-1-下单,messageBody: Order-1-下单
Handle Order Message: messageId: 0A0E089B386F18B4AAC23B99C8510001,topic: DefaultCluster,tags: Tags,keys: Order-1-结算,messageBody: Order-1-结算
Handle Order Message: messageId: 0A0E089B386F18B4AAC23B99C8540002,topic: DefaultCluster,tags: Tags,keys: Order-1-支付,messageBody: Order-1-支付
Handle Order Message: messageId: 0A0E089B386F18B4AAC23B99C8580003,topic: DefaultCluster,tags: Tags,keys: Order-1-完成,messageBody: Order-1-完成
Handle Order Message: messageId: 0A0E089B386F18B4AAC23B99C85A0004,topic: DefaultCluster,tags: Tags,keys: Order-2-下单,messageBody: Order-2-下单
Handle Order Message: messageId: 0A0E089B386F18B4AAC23B99C85F0005,topic: DefaultCluster,tags: Tags,keys: Order-2-结算,messageBody: Order-2-结算
Handle Order Message: messageId: 0A0E089B386F18B4AAC23B99C8620006,topic: DefaultCluster,tags: Tags,keys: Order-2-支付,messageBody: Order-2-支付
Handle Order Message: messageId: 0A0E089B386F18B4AAC23B99C8680007,topic: DefaultCluster,tags: Tags,keys: Order-2-完成,messageBody: Order-2-完成
Handle Order Message: messageId: 0A0E089B386F18B4AAC23B99C86E0008,topic: DefaultCluster,tags: Tags,keys: Order-3-下单,messageBody: Order-3-下单
Handle Order Message: messageId: 0A0E089B386F18B4AAC23B99C8720009,topic: DefaultCluster,tags: Tags,keys: Order-3-结算,messageBody: Order-3-结算
Handle Order Message: messageId: 0A0E089B386F18B4AAC23B99C881000A,topic: DefaultCluster,tags: Tags,keys: Order-3-支付,messageBody: Order-3-支付
Handle Order Message: messageId: 0A0E089B386F18B4AAC23B99C883000B,topic: DefaultCluster,tags: Tags,keys: Order-3-完成,messageBody: Order-3-完成

    可以看到，在消费端，消息完全按照发送的顺序进行了消费，保证了消息的顺序性。

  3. 在多Consumer的情况下，不同Queue上的消息可以并发消费，同一个Queue上的消息仍然可以保证顺序消费。

张申傲
关注
专栏目录
RocketMQ顺序消费
fajing_feiyue的博客
05-10 2740
一、rocketmq顺序消费的原理 1、消息的有序性是指消息的消费顺序能够与消息的发送顺序一致。但是有时候我们从业务需要上面并不需要保证所有消息严格按照消费顺序完全一致。例如，一个订单的下单、付款、出库等操作是不同替换顺序。但是有A订单和B订单，并不需要保证A订单与B订单的顺序。 2、RocketMQ采用了局部顺序一致性的机制，一组消息发送到同一个队列中来保证发送顺序的有序性，然后再由消费者进行。消费的时候通过一个队列只会被一个线程取到 ，第二个线程无法访问这个队列 来保证队列有序性。rocketmq可以
rocketmq详解（持续更新）
热门推荐
Ferao的博客
05-08 6万+
一、MQ阐述 简单图示 [注] 消息队列是一种"先进先出"的数据结构 不使用队列的情况下生产者与消费者之间是通过RPC交互的 应用场景 应用解耦 问题描述 系统的耦合性越高，容错性就越低，以电商应用为例，用户创建订单后，如果耦合调用库存系统、物流系统、支付系统，任何一个子系统出了故障或者因为升级等原因暂时不可用，都会造成下单操作异常 解耦含义 使用消息队列解耦，系统的耦合性就会...
详解RocketMQ 顺序消费机制
华为云官方博客
05-30 1152
顺序消息是指对于一个指定的 Topic ，消息严格按照先进先出（FIFO）的原则进行消息发布和消费，即先发布的消息先消费，后发布的消息后消费。
RocketMQ 之顺序消息
最新发布
FireFox1997
08-02 848
顺序消息指的是按照消息发送的顺序，确保消息在消费者端也能按照相同的顺序进行消费。这种特性在需要严格顺序处理的场景中非常重要，例如订单处理、金融交易等。RocketMQ 的顺序消息通过队列分区和消息队列选择器的机制，确保了消息的顺序性。在实际应用中，通过合理设计队列和消息选择策略，可以有效保证消息的有序处理。在未来的开发中，充分利用顺序消息可以大大提升系统的可靠性和一致性。
RocketMQ-顺序消费原理
acq的博客
05-15 202
顺序消费 生产者指定messageQueue 消费者启动的时候进行锁定 ConsumeMessageOrderlyService#lockMQPeriodically有个定时任务，会去锁定messageQueue。 相当于用broker做分布式锁。 锁状态存在ProcessQueue中。 然后在DefaultMQPushConsumerImpl#pullMessage拉取消息的时候，会判断ProcessQueue是否被自己锁定，只有被自己加锁了，才可以去拉取消息。 ...
RocketMQ系列之顺序消费
姑苏城外（り寂寞
06-04 2万+
前言 上节我们介绍了RMQ的两大亮点，重试和重复消费的问题，其实重试才能算亮点，重复消费最终还是要由我们自己来解决这个问题，RMQ自身并没有提供很好的机制，至少目前是没有，不知道将来会不会有，OK扯远了，今天呢，我们再来介绍RMQ一个不错的地方，那就是顺序消费，RMQ是可以保证同一个queue中的消息被顺序的消费。 RMQ实现如何实现顺序消费？ 生产者Producer在生产消息时将需要顺序消费的消息发送到同一个queue下，每个topic默认是有4个queue所以Producer需要一个队列选择.
RocketMQ理解(顺序消费)
weixin_36802143的博客
03-05 726
1.场景分析 顺序消费是指消息的产生顺序和消费顺序相同 假设有个下单场景，每个阶段需要发邮件通知用户订单状态变化。用户付款完成时系统给用户发送订单已付款邮件，订单已发货时给用户发送订单已发货邮件，订单完成时给用户发送订单已完成邮件。 发送邮件的操作为了不阻塞订单主流程，可以通过mq消息来解耦，下游邮件服务器收到mq消息后发送具体邮件，已付款邮件、已发货邮件、订单已完成邮件这三个消息，下游的邮件服务...
RocketMQ 源码分析 —— 集成 Spring Boot
芋艿V
05-05 626
点击上方“芋道源码”，选择“设为星标”做积极的人，而不是积极废人！源码精品专栏原创 | Java 2020 超神之路，很肝~中文详细注释的开源项目RPC 框架 Dubbo 源码解析网络...
RocketMQ一个实例能消费另一个就不能消费？
java_beautiful的博客
07-20 2188
RocketMQ 有两种消费模式，集群模式和广播模式。 集群模式是指 RocketMQ 中的一条消息只能被同一个消费者组中的一个消费者消费。如下图，Producer 向 TopicTest 这个 Topic 并发写入 3 条新消息，分别被分配到了 MessageQueue1~MessageQueue3 这 3 个队列，然后 Group 中的三个 Consumer 分别消费了一条消息： ...
RocketMQ底层详解
qq_47815451的博客
10-16 650
RocketMQ底层详解 架构 Broker RocketMQ的服务，或者说是一个进程叫做Broker，作用是存储和转发消息。RocketMQ单机大约能承受10万QPS的请求。为了提升Broker的可用性，以及提升服务器性能，通常会做集群的部署。每个Broker保存总数据的一部分，因此可以实现横向扩展。 为了提升可靠性（防止数据丢失），每个Broker可以拥有自己的副本（slave）。 默认情况，读写都发生在主节点上。在slaveReadEnable = true的情况下，slave也可以参与读负载，
RocketMQ学习(二)——重要参数和主从消息同步
hxyascx的博客
10-18 614
生产者核心参数 producerGroup： 组名。一个应用（JVM）中组名不能重复。 defaultTopicQueueNums： 默认的topic对于Queue的数量，默认是4。 sendMsgTimeout： 生产者发送消息的超时时间。 compressMsgBodyOverHowmuch： 消息超过多大开始进行压缩，默认压缩字节4096。 retryTimesWhenSendFailed：...
23. rocketmq顺序消费
ZXH240651200的博客
12-08 4676
之前的文章，都是基于并发消费讲解的，今天来分析一下顺序消费
RocketMQ的顺序消费
maimai1993的博客
05-29 9631
上游系统通过消息队列，发送一个订单的状态操作信息，下游系统如何接受消息，并且需要严格保证订单状态的操作顺序性
rocketmq顺序消费
shaofei_huai的博客
09-21 275
在rocketmq总topic下包含多个queue，发送消息时如果不指定会随机发送到不同queue，此时消费者无法保证顺序消费。参考下图，发送时发送了producetMessage0-producetMessage9，但消费时顺序变了。 解决顺序消费的方法比较简单，第一步是在生产者发送时将消息发送到同一个queue。要达到该效果可以实现MessageQueueSelector，在其select方法中自定义发送到哪个queue。代码如下： public class ...
RocketMQ-初体验RocketMQ(07)-使用API操作RocketMQ_顺序消息 ordermessage
小工匠
11-10 1万+
文章目录顺序消息的概念顺序消费的原理消费状态演示ProducerConsumer 顺序消息的概念 消息有序指的是可以按照消息的发送顺序来消费(FIFO)。 RocketMQ可以严格的保证消息有序，可以分为分区有序或者全局有序。 顺序消费的原理 在默认的情况下消息发送会采取Round Robin轮询方式把消息发送到不同的queue(分区队列)； 而消费消息的时候从多个queue上拉取消息，这种...
源码分析RocketMQ顺序消息消费实现原理
中间件兴趣圈
03-02 1万+
所谓顺序消费，rocketmq支持同一消费队列上的消息顺序消费。 消息消费涉及3个点： 1、消息队列重新负载 2、消息拉取 3、消息消费 按照消息消费步骤来揭开RocketMQ顺序消息消费实现原理。 1、消息队列负载 RocketMQ在同一个JVM进程拥有一个clientConfigId(客户端ID)，该JVM进程中不同的消息消费组的消息客户端ID相同，因为在JVM进程中对于每一个C...
RocketMQ源码学习 (十四) 顺序消费服务原理
Misteltoe的博客
11-07 533
之前的内容里学习了rocketMQ的消费者并发消费的相关原理和源码，本篇文章开始学习顺序消费的相关原理。首先，什么是顺序消费？，在一个queue里面，消息需要按照FIFO的规则，RocketMQ不支持全局顺序消费，只支持在一个主题下的一个queue队列是有序的，如果想要做到全局顺序消费该怎么办呢？设置只有一个queue就可以了，但是这样性能很低。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

张申傲

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值