RocketMQ顺序消费

于 2024-07-22 10:36:23 发布
阅读量499 收藏 26
点赞数 21
分类专栏： java优秀例子 文章标签： rocketmq 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lin_Miao_09/article/details/140588029
版权

一、什么是顺序消费

RocketMQ 支持两种类型的顺序消息消费：分区顺序消息（Partition Ordered Messages）和全局顺序消息（Global Ordered Messages）。这两种方式都能确保消息的顺序消费，但它们的工作机制有所不同。

二、分区顺序消息

在分区顺序消息中，RocketMQ 保证在同一个消息队列（Message Queue）中的消息按照发送的顺序被消费。为了实现这一点，你需要做以下几点：

  1. 消息分发：在发送消息时，你需要通过某种键（Sharding Key）将相关联的消息发送到相同的队列中。通常，这个键是业务逻辑中的一部分，比如用户ID或者订单ID。

  2. 消费控制：在消费端，你需要配置一个顺序消费的消费者（Ordered Consumer），这种消费者在处理完当前的消息之前不会接收到下一个消息。RocketMQ 会确保每个队列只被一个线程消费，从而保证顺序。

三、全局顺序消息

全局顺序消息比分区顺序消息更进一步，它不仅要求在同一个队列中的消息有序，而且要求整个主题的所有消息都按照发送的顺序被消费。这意味着所有的消息都必须进入同一个队列中，这在高并发场景下可能会成为一个瓶颈。

为了实现全局顺序消息，你同样需要配置一个顺序消费的消费者，但是你只能有一个消息队列，所以所有消息都会被发送到这个队列中，从而确保全局顺序。

实现顺序消费的步骤

  1. 配置消费者：在消费者的配置中，你需要明确指定这是一个顺序消费者。这可以通过实现MQPushConsumer接口并重写consumeMessage方法来完成，同时需要在setConsumeFromWhere和subscribe方法中正确配置。

  2. 消息发送：在发送消息时，使用Sharding Key来确保相关联的消息被发送到相同的队列中（对于分区顺序消息）。

  3. 处理消息：在consumeMessage方法中，确保按顺序处理消息。RocketMQ 的设计会保证消息在一个队列中的顺序消费。

注意事项

  • 性能影响：顺序消费会降低系统的吞吐量，因为它限制了并行处理的能力。

  • 错误处理：如果在消费过程中发生错误，需要妥善处理，以避免阻塞后续消息的消费。

在实际应用中，你可能需要根据业务需求权衡是否需要顺序消费，以及选择哪种顺序消费策略。在某些情况下，分区顺序消息可能已经足够满足业务需求，而无需使用全局顺序消息。

四、实现例子

全局顺序和分区顺序，主要根据推送设置hashKey来实现的。

发送消息：

下面简单实现一个并发推送消息，来验证消息的顺序处理。

private static final String TOPIC = "TEST_TOPIC";

@Resource
private RocketMQTemplate rocketMQTemplate;

@Test
public void send(){
    VolatileExample example = new VolatileExample();

    Thread thread1 = new Thread(() -> {
        for (int i = 0; i < 100; i++) {
            int temp = example.increment();
            Test test= new Test();
            test.setNum(temp+"");
            // 指定相同的hashKey, 确保所有消息推送到同一个队列
            // 如何消息中用关联id，例如订单id, 可以将订单id作用hashKey, 就能够实现分区顺序
            rocketMQTemplate.syncSendOrderly(TOPIC, test, "hashKey");
            System.out.println(temp);
        }
    });
    Thread thread2 = new Thread(() -> {
        for (int i = 0; i < 100; i++) {
            int temp = example.increment();
            Test test= new Test();
            test.setNum(temp+"");
            // 指定相同的hashKey, 确保所有消息推送到同一个队列
            // 如何消息中用关联id，例如订单id, 可以将订单id作用hashKey, 就能够实现分区顺序
            rocketMQTemplate.syncSendOrderly(TOPIC, test, "hashKey");
            System.out.println(temp);
        }
    });
    Thread thread3 = new Thread(() -> {
        for (int i = 0; i < 100; i++) {
            int temp = example.increment();
            Test test= new Test();
            test.setNum(temp+"");
            // 指定相同的hashKey, 确保所有消息推送到同一个队列
            // 如何消息中用关联id，例如订单id, 可以将订单id作用hashKey, 就能够实现分区顺序
            rocketMQTemplate.syncSendOrderly(TOPIC, test, "hashKey");
            System.out.println(temp);
        }
    });

    thread1.start();
    thread2.start();
    thread3.start();
    try {
        thread1.join();
        thread2.join();
        thread3.join();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    System.out.println("Counter: " + example.counter);



}

static class VolatileExample {
    volatile int counter = 0;

    public synchronized int increment() {
        return counter++;
    }
}

消费消息：

消息消费默认是并发消费，并发消费无法保证顺序性，所以需要修改配置，设置顺序消费。

/**  ConsumeMode.ORDERLY  顺序消费  */
@RocketMQMessageListener(topic = "TEST_TOPIC", nameServer = "${rocketmq.name-server}", consumerGroup = "TEST_GROUP" , consumeMode = ConsumeMode.ORDERLY)
@Component
@Slf4j
public class UsersComsumerListener implements RocketMQListener<String> {


    @Override
    public void onMessage(String msg) {
        // 事件处理
        log.info("MQ消息：{}", msg);
    }

}

五、源码分析

/**
     * Same to {@link #syncSend(String, Object)} with send orderly with hashKey by specified.
     *
     * @param destination formats: topicName:tags
     * @param payload     the Object to use as payload
     * @param hashKey     use this key to select queue. for example: orderId, productId ...
     * @return {@link SendResult}
     */
    public SendResult syncSendOrderly(String destination, Object payload, String hashKey) {
        // hashKey 决定消息推送到哪个queue
        return syncSendOrderly(destination, payload, hashKey, producer.getSendMsgTimeout());
    }

// 可以根据推送源码查询下去，看到选择队列的方法

方法链路：

org.apache.rocketmq.spring.core.RocketMQTemplate#syncSendOrderly(java.lang.String, java.lang.Object, java.lang.String)

org.apache.rocketmq.spring.core.RocketMQTemplate#syncSendOrderly(java.lang.String, java.lang.Object, java.lang.String, long)

org.apache.rocketmq.spring.core.RocketMQTemplate#syncSendOrderly(java.lang.String, org.springframework.messaging.Message<?>, java.lang.String, long)

org.apache.rocketmq.client.producer.DefaultMQProducer#send(org.apache.rocketmq.common.message.Message, org.apache.rocketmq.client.producer.MessageQueueSelector, java.lang.Object, long)

org.apache.rocketmq.client.impl.producer.DefaultMQProducerImpl#send(org.apache.rocketmq.common.message.Message, org.apache.rocketmq.client.producer.MessageQueueSelector, java.lang.Object, long)

org.apache.rocketmq.client.impl.producer.DefaultMQProducerImpl#sendSelectImpl

org.apache.rocketmq.client.producer.selector.SelectMessageQueueByHash#select

找到了选择队列的方法：

@Override
    public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {
        int value = arg.hashCode();
        if (value < 0) {
            // 小于0时，取绝对值，为正数
            value = Math.abs(value);
        }
        // 根据队列数，模运算找到对应的队列数（标识）
        value = value % mqs.size();
        // 根据hashCode选择队列
        return mqs.get(value);
    }

设置消费者注解

@RocketMQMessageListener 中 consumeMode 设置了顺序消息 ConsumeMode.ORDERLY

看一下 ConsumeMode.ORDERLY  是如何实现顺序消费

org.apache.rocketmq.spring.autoconfigure.ListenerContainerConfiguration#afterSingletonsInstantiated

org.apache.rocketmq.spring.autoconfigure.ListenerContainerConfiguration#registerContainer

org.apache.rocketmq.spring.support.DefaultRocketMQListenerContainer

在初始化消费者方法

org.apache.rocketmq.spring.support.DefaultRocketMQListenerContainer#initRocketMQPushConsumer

private void initRocketMQPushConsumer() throws MQClientException {
        Assert.notNull(rocketMQListener, "Property 'rocketMQListener' is required");
        Assert.notNull(consumerGroup, "Property 'consumerGroup' is required");
        Assert.notNull(nameServer, "Property 'nameServer' is required");
        Assert.notNull(topic, "Property 'topic' is required");

        RPCHook rpcHook = RocketMQUtil.getRPCHookByAkSk(applicationContext.getEnvironment(),
            this.rocketMQMessageListener.accessKey(), this.rocketMQMessageListener.secretKey());
        boolean enableMsgTrace = rocketMQMessageListener.enableMsgTrace();
        if (Objects.nonNull(rpcHook)) {
            consumer = new DefaultMQPushConsumer(consumerGroup, rpcHook, new AllocateMessageQueueAveragely(),
                enableMsgTrace, this.applicationContext.getEnvironment().
                resolveRequiredPlaceholders(this.rocketMQMessageListener.customizedTraceTopic()));
            consumer.setVipChannelEnabled(false);
            consumer.setInstanceName(RocketMQUtil.getInstanceName(rpcHook, consumerGroup));
        } else {
            log.debug("Access-key or secret-key not configure in " + this + ".");
            consumer = new DefaultMQPushConsumer(consumerGroup, enableMsgTrace,
                    this.applicationContext.getEnvironment().
                    resolveRequiredPlaceholders(this.rocketMQMessageListener.customizedTraceTopic()));
        }

        String customizedNameServer = this.applicationContext.getEnvironment().resolveRequiredPlaceholders(this.rocketMQMessageListener.nameServer());
        if (customizedNameServer != null) {
            consumer.setNamesrvAddr(customizedNameServer);
        } else {
            consumer.setNamesrvAddr(nameServer);
        }
        if (accessChannel != null) {
            consumer.setAccessChannel(accessChannel);
        }
        consumer.setConsumeThreadMax(consumeThreadMax);
        if (consumeThreadMax < consumer.getConsumeThreadMin()) {
            consumer.setConsumeThreadMin(consumeThreadMax);
        }
        consumer.setConsumeTimeout(consumeTimeout);
        consumer.setInstanceName(this.name);

        switch (messageModel) {
            case BROADCASTING:
                consumer.setMessageModel(org.apache.rocketmq.common.protocol.heartbeat.MessageModel.BROADCASTING);
                break;
            case CLUSTERING:
                consumer.setMessageModel(org.apache.rocketmq.common.protocol.heartbeat.MessageModel.CLUSTERING);
                break;
            default:
                throw new IllegalArgumentException("Property 'messageModel' was wrong.");
        }

        switch (selectorType) {
            case TAG:
                consumer.subscribe(topic, selectorExpression);
                break;
            case SQL92:
                consumer.subscribe(topic, MessageSelector.bySql(selectorExpression));
                break;
            default:
                throw new IllegalArgumentException("Property 'selectorType' was wrong.");
        }

       // 在这个地方可以看到，根据不同的消费模式设置消息监听者
        switch (consumeMode) {
            case ORDERLY:
                consumer.setMessageListener(new DefaultMessageListenerOrderly());
                break;
            case CONCURRENTLY:
                consumer.setMessageListener(new DefaultMessageListenerConcurrently());
                break;
            default:
                throw new IllegalArgumentException("Property 'consumeMode' was wrong.");
        }

        if (rocketMQListener instanceof RocketMQPushConsumerLifecycleListener) {
            ((RocketMQPushConsumerLifecycleListener) rocketMQListener).prepareStart(consumer);
        }

    }

默认顺序消息侦听器

org.apache.rocketmq.spring.support.DefaultRocketMQListenerContainer.DefaultMessageListenerOrderly

实现 MessageListenerOrderly ，顺序消息监听器默认使用手动ACK的方式

public class DefaultMessageListenerOrderly implements MessageListenerOrderly {

        @SuppressWarnings("unchecked")
        @Override
        public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
            for (MessageExt messageExt : msgs) {
                log.debug("received msg: {}", messageExt);
                try {
                    long now = System.currentTimeMillis();
                    rocketMQListener.onMessage(doConvertMessage(messageExt));
                    long costTime = System.currentTimeMillis() - now;
                    log.info("consume {} cost: {} ms", messageExt.getMsgId(), costTime);
                } catch (Exception e) {
                    log.warn("consume message failed. messageExt:{}", messageExt, e);
              // 消费失败时，默认暂时挂起1秒不进行消费
                    context.setSuspendCurrentQueueTimeMillis(suspendCurrentQueueTimeMillis);
                    return ConsumeOrderlyStatus.SUSPEND_CURRENT_QUEUE_A_MOMENT;
                }
            }

            return ConsumeOrderlyStatus.SUCCESS;
        }
    }

Lin_Miao_09
关注
  • 21
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
rocketMq 顺序消费
congge
05-25 2029
什么是顺序消费？ 消息有序指的是一类消息消费时，能按照发送的顺序来消费。例如：一个订单产生了 3 条消息，分别是订单创建、订单付款、订单完成。消费时，要按照这个顺序消费才有意义。与此同时多笔订单之间又是可以并行消费的。 rocketmq是怎么实现顺序消费的呢？ ①rocketmq保证同一个订单的消息,一定要发送到同一个队列 ②并且该队列只有一个消费者,也就是说 同一个队列,不能出现多个消费者并行消...
【Java】如何提升RocketMQ顺序消费性能？
最新发布
JAVA_aik的博客
06-12 1057
我们先来了解一下 RocketMQ 顺序消费的实现原理。RocketMQ 支持局部顺序消息消费，可以保证同一个消费队列上的消息顺序消费。例如，消息发送者向主题为 ORDER_TOPIC 的 4 个队列共发送 12 条消息， RocketMQ 可以保证 1、4、8 这三条按顺序消费，但无法保证消息 4 和消息 2 的先后顺序。那 RocketMQ 是怎么做到分区顺序消费的呢？我们可以看一下它的工作机制：顺序消费实现的核心要点可以细分为三个阶段。
rocketmq顺序消费
luzhensmart的专栏
04-27 430
顺序消费,什么是顺序消费？ 指的是可以按照消息的发送顺序来消费。例如：一笔订单产生了 3 条消息，分别是订单创建、订单付款、订单完成。消费时，要按照顺序依次消费才有意义。与此同时多笔订单之间又是可以并行消费的。 关于消息的消费过程中,可能遇到的异常情况,可以参考该博客：https://www.jianshu.com/p/453c6e7ff81c rocketmq是怎么实现顺序消费的呢？ ①ro...
详解RocketMQ 顺序消费机制
weixin_58186846的博客
01-18 1414
顺序消息是指对于一个指定的 Topic ，消息严格按照先进先出（FIFO）的原则进行消息发布和消费，即先发布的消息先消费，后发布的消息后消费。
RocketMq顺序消费
wang_jun_jie的博客
11-22 458
RocketMq如何保证消息的顺序消费： 由于RocketMq的消息都是存储在topic中，而topic中又有不同的队列，RocketMq会自动进行负载均衡处理，使消息尽量均匀的分布到不同的队列中去，而队列的属性又是先进先出，所以我们只需要确保把消息发送到同一个队列中，消费者单线程进行消费，就可以确保消息的顺序性。 producer代码： for(int i=0;i<20;i++) { Message message=new Message("order_producer_topic",
rocketmq顺序消费问题
C18298182575的博客
11-12 1816
场景举例 用户下单，付款，发货，完成，每一个步骤发送完成，发送mq消息到下游系统处理（消费客户端），同一个订单要保证顺序消费。 mq实现思路 选择mq顺序消息，实现思路， 生产者：发送消息的时候保证同一个订单的业务消息，发送到同一个队列；订单号对队列总和取模，找到指定队列 消费者：每一个消费线程可以保证只消费一个队列的消息，怎么保证消费线程，只消费一个队列的消息原理...可进一步探究 代码 生产者 /** * 顺序消息生产者 */ @Slf4j public class Ordered
23. rocketmq顺序消费
ZXH240651200的博客
12-08 4640
之前的文章，都是基于并发消费讲解的，今天来分析一下顺序消费
rocketmq 顺序消费
a1k2l45k的博客
02-20 113
https://blog.csdn.net/loveme888/article/details/103006512
RocketMQ顺序消费模式下消息堵塞问题排查处理
zjb1377072049的博客
07-25 2807
RocketMQ顺序消费模式下消息堵塞问题排查处理
RocketMQ使用手册
06-21
* 能够保证严格的消息顺序 * 提供丰富的消息拉取模式 * 高效的订阅者水平扩展能力 * 实时的消息订阅机制 * 亿级消息堆积能力 选用理由： * 强调集群无单点，可扩展，任意一点高可用，水平可扩展 * 海量消息堆积...
rocketmq使用.zip
02-21
顺序消息保证消息按照特定的顺序进行消费，适用于日志记录、库存管理等场景。消息过滤支持基于内容和标签的过滤规则，帮助消费者只获取感兴趣的消息。 为了更好地使用RocketMQ，你需要熟悉其配置、API调用、监控和...
RocketMQ: 4.9.5
01-07
3. **顺序消息**：RocketMQ 提供了全局顺序消息和分区顺序消息，保证了在特定场景下消息的严格顺序。这对于金融交易等对消息顺序有强要求的业务非常关键。 4. **事务消息**：RocketMQ 支持分布式事务，确保消息的...
rocketmq中间件
02-12
- **顺序消息**：保证消息按照发送顺序消费，适用于金融交易等对顺序敏感的场景。 - **分布式事务**：提供分布式事务的支持，保证跨服务操作的原子性。 6. ** RocketMQ的应用场景** - **大数据处理**：作为数据...
springboot整合rocketmq
06-07
SpringBoot整合RocketMQ是将流行的Java微服务框架Spring Boot与分布式消息中间件RocketMQ结合，以实现...在学习过程中，还可以探索RocketMQ的高级特性，如分布式事务、定时消息、顺序消息等功能，进一步提升技术水平。
controller入参异常 No primary or default constructor found for class
Lin_Miao_09的博客
03-22 7223
一、记一次的常见报错 java.lang.IllegalStateException: No primary or default constructor found for class java.time.LocalDateTime 错误写法： @GetMapping public String query(LocalDate start,LocalDate end) { return "开始时间："+start+" 结束时间："+end; } 该写法springMVC会默认根据参数名称“
403跨域，什么是跨域，如何解决。（CROS）
Lin_Miao_09的博客
09-22 3009
当请求的协议、域名、端口，任一不相同时就会出现跨域。当前URL被请求URL是否跨域原因否同源（协议、域名、端口都相同）是协议不同（http/https）是域名不同（www.abc.com/www.def.com）是端口不同（8080/8181）
java使用hutool工具包实现发送邮件功能
Lin_Miao_09的博客
10-21 2688
一、背景 检测项目运行状态，出现异常时，向项目负责人发送通知邮件。 二、采用技术 主要使用java的mail工具类和hutool工具包 三、具体实现 1、邮箱配置 小编这个采用的是QQ邮箱，以QQ邮箱为例，设置大同小异。 登录网页版的QQ邮箱后，点击设置 点击账户 找到相应的服务并开启，开启后会有对应授权码，后面代码实现会使用到，两种的授权码任选一种即可。 2、引入对应的jar <!-- hutool工具包 --> <dependency&g.
项目启动报java.lang.NoSuchMethodError:....Ljava/util/List；
Lin_Miao_09的博客
04-22 1864
出现该错误的原因为，所传的值类型与接收的类型不符合。 例如：mybatis中的xml中参数类型与传递参数不付合。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值