rocketmq 消息消费后处理机制

最新推荐文章于 2024-06-25 18:11:36 发布
最新推荐文章于 2024-06-25 18:11:36 发布
阅读量4.2k 收藏 2
点赞数
分类专栏： RocketMQ源码分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Aqu415/article/details/106333296
版权

一句话概述：消息消费后有两个地方做ack。第一个地方是消费失败后同步将消费失败的消息发送回broker，另一个地方是定时任务（参见org.apache.rocketmq.client.impl.producer.DefaultMQProducerImpl#start(boolean)

--> org.apache.rocketmq.client.consumer.store.RemoteBrokerOffsetStore#persistAll）

消息拉取

以push模式消费为例，消息拉取与消费的入口核心代码：

org.apache.rocketmq.client.impl.consumer.DefaultMQPushConsumerImpl#pullMessage

PullCallback pullCallback = new PullCallback() {
            @Override
            public void onSuccess(PullResult pullResult) {
                if (pullResult != null) {
                    pullResult = DefaultMQPushConsumerImpl.this.pullAPIWrapper.processPullResult(pullRequest.getMessageQueue(), pullResult, subscriptionData);

                    switch (pullResult.getPullStatus()) {
                        case FOUND:
                            long prevRequestOffset = pullRequest.getNextOffset();
                            pullRequest.setNextOffset(pullResult.getNextBeginOffset());
                            long pullRT = System.currentTimeMillis() - beginTimestamp;
                            DefaultMQPushConsumerImpl.this.getConsumerStatsManager().incPullRT(pullRequest.getConsumerGroup(),
                                pullRequest.getMessageQueue().getTopic(), pullRT);

                            long firstMsgOffset = Long.MAX_VALUE;
                            if (pullResult.getMsgFoundList() == null || pullResult.getMsgFoundList().isEmpty()) {
                                DefaultMQPushConsumerImpl.this.executePullRequestImmediately(pullRequest);
                            } else {
                                firstMsgOffset = pullResult.getMsgFoundList().get(0).getQueueOffset();

                                DefaultMQPushConsumerImpl.this.getConsumerStatsManager().incPullTPS(pullRequest.getConsumerGroup(),
                                    pullRequest.getMessageQueue().getTopic(), pullResult.getMsgFoundList().size());

//将消息放入ProcessQuesu中；校验该队列是否在消费中，只会对顺序消费的consumeMessageService有影响，如果正在消费则不提交任务
                                boolean dispatchToConsume = processQueue.putMessage(pullResult.getMsgFoundList());
                                
//如果拉取到消息，会将消息封装成一个ConsumeRequest对象放入队列中待消费
DefaultMQPushConsumerImpl.this.consumeMessageService.submitConsumeRequest(
                                    pullResult.getMsgFoundList(),
                                    processQueue,
                                    pullRequest.getMessageQueue(),
                                    dispatchToConsume);

                                if (DefaultMQPushConsumerImpl.this.defaultMQPushConsumer.getPullInterval() > 0) {
                                    DefaultMQPushConsumerImpl.this.executePullRequestLater(pullRequest, DefaultMQPushConsumerImpl.this.defaultMQPushConsumer.getPullInterval());
                                } else {
                                    DefaultMQPushConsumerImpl.this.executePullRequestImmediately(pullRequest);
                                }
                            }

org.apache.rocketmq.client.impl.consumer.ProcessQueue#putMessage 方法是将拉取到的消息放入到客户端本地的processQueue中，processQueue是消费端对broker端消费队列逻辑上的一个镜像；客户端拉取消息后都会先将消息存入processqueue中再进行消费；

在broker端处理消息拉取的processor是 PullMessageProcessor，在成功拉取到消息后会根据是否需要保存消费进度将拉取的进度保存在内存中

if (storeOffsetEnable) {
            this.brokerController.getConsumerOffsetManager().commitOffset(RemotingHelper.parseChannelRemoteAddr(channel),requestHeader.getConsumerGroup(), requestHeader.getTopic(), requestHeader.getQueueId(), requestHeader.getCommitOffset());
        }

提交消费

代码回到提交client 提交 ConsumeRequest的代码，在client端会根据是并发消费还是顺序消费执行不同的逻辑；

DefaultMQPushConsumerImpl.this.consumeMessageService.submitConsumeRequest(
                                    pullResult.getMsgFoundList(),
                                    processQueue,
                                    pullRequest.getMessageQueue(),
                                    dispatchToConsume);

并发消费 

执行方法 

org.apache.rocketmq.client.impl.consumer.ConsumeMessageConcurrentlyService#submitConsumeRequest

这里会根据 consumeMessageBatchMaxSize 做分批次将消息分批分装进多个ConsumeRequest任务，该类是一个Runnale类，我们看看它的run方法：

@Override
        public void run() {
            if (this.processQueue.isDropped()) {
                log.info("the message queue not be able to consume, because it's dropped. group={} {}", ConsumeMessageConcurrentlyService.this.consumerGroup, this.messageQueue);
                return;
            }

//NO.1
            MessageListenerConcurrently listener = ConsumeMessageConcurrentlyService.this.messageListener;            

...省略代码...
                
//NO.2
ConsumeMessageConcurrentlyService.this.defaultMQPushConsumerImpl.executeHookBefore(consumeMessageContext);
            }

            long beginTimestamp = System.currentTimeMillis();
            boolean hasException = false;
            ConsumeReturnType returnType = ConsumeReturnType.SUCCESS;
            try {
                ConsumeMessageConcurrentlyService.this.resetRetryTopic(msgs);
                if (msgs != null && !msgs.isEmpty()) {
                    for (MessageExt msg : msgs) {
                        MessageAccessor.setConsumeStartTimeStamp(msg, String.valueOf(System.currentTimeMillis()));
                    }
                }
//NO.3
                status = listener.consumeMessage(Collections.unmodifiableList(msgs), context);
            } catch (Throwable e) {
                log.warn("consumeMessage exception: {} Group: {} Msgs: {} MQ: {}",
                    RemotingHelper.exceptionSimpleDesc(e),
                    ConsumeMessageConcurrentlyService.this.consumerGroup,
                    msgs,
                    messageQueue);
                hasException = true;
            }
            long consumeRT = System.currentTimeMillis() - beginTimestamp;            

...省略代码...

            if (ConsumeMessageConcurrentlyService.this.defaultMQPushConsumerImpl.hasHook()) {
                consumeMessageContext.getProps().put(MixAll.CONSUME_CONTEXT_TYPE, returnType.name());
            }

//NO.4
            if (null == status) {
                log.warn("consumeMessage return null, Group: {} Msgs: {} MQ: {}",
                    ConsumeMessageConcurrentlyService.this.consumerGroup,
                    msgs,
                    messageQueue);
                status = ConsumeConcurrentlyStatus.RECONSUME_LATER;
            }

            if (ConsumeMessageConcurrentlyService.this.defaultMQPushConsumerImpl.hasHook()) {
                consumeMessageContext.setStatus(status.toString());
                consumeMessageContext.setSuccess(ConsumeConcurrentlyStatus.CONSUME_SUCCESS == status);

//NO.5                
ConsumeMessageConcurrentlyService.this.defaultMQPushConsumerImpl.executeHookAfter(consumeMessageContext);
            }

            ConsumeMessageConcurrentlyService.this.getConsumerStatsManager().incConsumeRT(ConsumeMessageConcurrentlyService.this.consumerGroup, messageQueue.getTopic(), consumeRT);

            if (!processQueue.isDropped()) {

//NO.6
                ConsumeMessageConcurrentlyService.this.processConsumeResult(status, context, this);
            } else {
                log.warn("processQueue is dropped without process consume result. messageQueue={}, msgs={}", messageQueue, msgs);
            }
        }

NO.1  获得我们注入的回调函数 MessageListenerConcurrently

NO.2 执行钩子函数的before

NO.3 执行回调函数的 consumeMessage 方法

NO.4 判断回调函数返回的状态，如果是空则设置为 ConsumeConcurrentlyStatus.RECONSUME_LATER;

NO.5 执行钩子函数的after方法

NO.6 处理执行结果（消费异常ack与消费进度管理）

消费异常ack与本地消费进度保存核心方法是：

org.apache.rocketmq.client.impl.consumer.ConsumeMessageConcurrentlyService#processConsumeResult

这里主要通过变量 

int ackIndex = context.getAckIndex(); 的设置来处理是否将消息回送到broker;大致逻辑是如果是中正常消费结束 ackindex会被设置成消息大size-1,那么后面代码不会进入循环进而不会将消息发送回broker;如果有异常就会将对应的消息通过retry的形式发回broker,如果发送失败则消费端会再次消费之前被标记失败的消息;
switch (this.defaultMQPushConsumer.getMessageModel()) {
            case BROADCASTING:
                for (int i = ackIndex + 1; i < consumeRequest.getMsgs().size(); i++) {
                    MessageExt msg = consumeRequest.getMsgs().get(i);
                    log.warn("BROADCASTING, the message consume failed, drop it, {}", msg.toString());
                }
                break;
            case CLUSTERING:
                List<MessageExt> msgBackFailed = new ArrayList<MessageExt>(consumeRequest.getMsgs().size());
                for (int i = ackIndex + 1; i < consumeRequest.getMsgs().size(); i++) {
                    MessageExt msg = consumeRequest.getMsgs().get(i);
//NO.1
                    boolean result = this.sendMessageBack(msg, context);
                    if (!result) {
                        msg.setReconsumeTimes(msg.getReconsumeTimes() + 1);
                        msgBackFailed.add(msg);
                    }
                }

                if (!msgBackFailed.isEmpty()) {
//NO.2
                    consumeRequest.getMsgs().removeAll(msgBackFailed);
//NO.3
                    this.submitConsumeRequestLater(msgBackFailed, consumeRequest.getProcessQueue(), consumeRequest.getMessageQueue());
                }
                break;
            default:
                break;
        }
//NO.4
        long offset = consumeRequest.getProcessQueue().removeMessage(consumeRequest.getMsgs());
        if (offset >= 0 && !consumeRequest.getProcessQueue().isDropped()) {
//NO.5            
this.defaultMQPushConsumerImpl.getOffsetStore().updateOffset(consumeRequest.getMessageQueue(), offset, true);
        }

NO.1 将消费失败的消息发回broker，发送消息的cmd是：RequestCode.CONSUMER_SEND_MSG_BACK

NO.2 将发回失败的消息remove掉

NO.3 如果1过程失败，client会再次重试消费该消息

NO.4 这里会获得最小的一个已被确认消费消息的偏移量（这个方法有可能会引起集群模式下的重复消费问题，比如一个批次有消息m1、m2、m3,如果m1和m3被正常消费了，这个函数返回的偏移量会是m1的偏移量而不是m3的，所以自定义程序要保证程序幂等）

NO.5 将第四步的消费进度返回值存入本地缓存中

消费进度推送broker

在broker启动的时候会将该定时任务启动，主要逻辑是消费进度管理类：RemoteBrokerOffsetStore

org.apache.rocketmq.client.impl.producer.DefaultMQProducerImpl#start()
↓
org.apache.rocketmq.client.impl.producer.DefaultMQProducerImpl#start(boolean)
↓
org.apache.rocketmq.client.impl.factory.MQClientInstance#start
↓
org.apache.rocketmq.client.impl.factory.MQClientInstance#startScheduledTask（创建定时任务）
↓
org.apache.rocketmq.client.impl.factory.MQClientInstance#persistAllConsumerOffset
↓
org.apache.rocketmq.client.impl.consumer.DefaultMQPushConsumerImpl#persistConsumerOffset
↓
org.apache.rocketmq.client.MQHelper#resetOffsetByTimestamp(org.apache.rocketmq.common.protocol.heartbeat.MessageModel, java.lang.String, java.lang.String, java.lang.String, long)
↓
org.apache.rocketmq.client.consumer.store.RemoteBrokerOffsetStore#persistAll
    @Override
    public void persistAll(Set<MessageQueue> mqs) {
        if (null == mqs || mqs.isEmpty())
            return;

        final HashSet<MessageQueue> unusedMQ = new HashSet<MessageQueue>();
        if (!mqs.isEmpty()) {
            for (Map.Entry<MessageQueue, AtomicLong> entry : this.offsetTable.entrySet()) {
                MessageQueue mq = entry.getKey();
                AtomicLong offset = entry.getValue();
                if (offset != null) {
                    if (mqs.contains(mq)) {
                        try {
//NO.1
                            this.updateConsumeOffsetToBroker(mq, offset.get());
                            log.info("[persistAll] Group: {} ClientId: {} updateConsumeOffsetToBroker {} {}",
                                this.groupName,
                                this.mQClientFactory.getClientId(),
                                mq,
                                offset.get());
                        } catch (Exception e) {
                            log.error("updateConsumeOffsetToBroker exception, " + mq.toString(), e);
                        }
                    } else {
                        unusedMQ.add(mq);
                    }
                }
            }
        }

        if (!unusedMQ.isEmpty()) {
            for (MessageQueue mq : unusedMQ) {
                this.offsetTable.remove(mq);
                log.info("remove unused mq, {}, {}", mq, this.groupName);
            }
        }
    }

 NO.1 这里会将client端缓存的消费进度同步到broker端，cmd是  RequestCode.UPDATE_CONSUMER_OFFSET

broker会根据上传的offset做对应的更新

万物皆字节
关注
专栏目录
rocketmq消息队列
08-05
2. 高性能：RocketMQ设计了优化的批量发送和消费机制，以及高效的网络协议，支持每秒处理百万级别的消息吞吐量。 3. 消息持久化：RocketMQ支持消息的持久化存储，即使在系统故障后，也能保证消息不丢失。 4. 顺序...
RabbitMQ 之消息的可靠性投递
fall_hat的博客
03-20 635
消息的可靠性投递 默认情况下，消息发送端发送消息给 RabbitMQ 后，RabbitMQ 是不会返回任何信息的。 RabbitMQ 提供了两种确认消息是否投递成功的方法 设置 channel 为 transaction 模式，通过 AMQP 事务机制实现，这也是 AMQP 协议层面提供的解决方案 设置 channel 为 confirm 模式，这是 RabbitMQ 提供的解决方案 http...
RocketMq 各类消息消费与发送原理分析
weixin_38650898的博客
10-10 889
Rocket Mq 事务消息、延迟消息、消息重试源码分析
RocketMQ 基础教程-原理篇-消息的清理
最新发布
smart_an的专栏
06-25 332
1）对于RocketMQ系统来说，删除一个1G大小的文件，是一个压力巨大的IO操作。在删除过程中，系统性能会骤然下降。所以，其默认清理时间点为凌晨4点，访问量最小的时间。也正因如果，我们要保障磁盘空间的空闲率，不要使系统出现在其它时间点删除commitlog文件的情况。消息是被顺序存储在commitlog文件的，且消息大小不定长，所以消息的清理是不可能以消息为单位进行清理的，而是以commitlog文件为单位进行清理的。联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬。
RabbitMQ(二) - RabbitMQ与消息发布确认与返回、消费确认
玄霄
08-05 2410
SpringBoot与RabbitMQ整合后，对RabbitClient的“确认”进行了封装、使用方式与RabbitMQ官网不一致；
springboot基础(49): 整合RocketMQ
不积跬步，无以至千里
07-19 1262
整合RocketMQ。
SpringBoot接入最新版RocketMq-Spring2.2.0,消费者指定返回消息处理状态
技术初创者陈乐的博客
03-16 1252
SpringBoot接入最新版RocketMq-Spring2.2.0,消费者指定返回消息处理状态 因为用的是RocketMq4.8.0,因此接入最新的rocketmq-spring 首先引入依赖 <dependency> <groupId>org.apache.rocketmq</groupId> <artifactId>rocketmq-spring-boot-starter</artifactId> <versi
RocketMQ详解
2301_77661292的博客
08-28 198
在网络通讯中，Http请求默认采用同步请求方式，基于请求与响应模式，在客户端与服务器进行通讯时，客户端调用服务端接口后，必须等待服务端完成处理后返回结果给客户端才能继续执行，这种情况属于同步调用方式。如果服务器端发生网络延迟、不可达的情况，可能客户端也会受到影响。
深入探索RocketMQ源码：透视消息中间件的内核机制
12-22
延迟消息是RocketMQ的一大特色，允许设置延迟级别，使得消息在特定时间后才被消费。其处理流程涉及消息的特殊标记和时间轮算法，确保延迟效果的准确实现。 通过对RocketMQ源码的逐层解析，我们可以理解其内部工作...
RocketMQ高级原理：深入剖析消息系统的核心机制
12-22
《RocketMQ高级原理：深入剖析消息系统的核心机制》是一篇深度解析RocketMQ核心机制的文章，旨在帮助读者理解和掌握这款分布式消息中间件的工作原理。RocketMQ是阿里巴巴开源的一款高性能、高可用的消息中间件，广泛...
消息队列-RocketMQ1
08-08
- **重试机制**：在消费者端，如果消息推送超时，会无限次重试，超过一定次数后，可进行业务处理或持久化到数据库记录。 - **生产者端重试**：消息发送超时也会尝试重新发送。 - **消费者启动顺序**：在生产环境中，...
RocketMQ消息队列demo
01-09
- **延迟消息**：可以设定消息在未来某个时间点才被消费，用于定时任务或延后处理。 - **消息重试与死信队列**：RocketMQ提供消息重试机制，如果消息消费失败，会自动重试；多次失败后，消息会被放入死信队列，...
RabbitMQ学习笔记（二）消息确认机制
qq_42331185的博客
07-14 2409
1、我的另一篇文章中介绍了RabbitMQ的交换机类型、消费类型，经过一系列的demo测试时，我们在RabbitMQ的后台监控中可以发现一个现象，就是消息在被成功消费后，队列中就没有这个消息了，也就是删除了，那么疑问来了，RabbitMQ是怎么知道这个消息该不该被删除？什么时候删除？2、除了消费者，那么生产者怎么知道自己消息是否发送成功到RabbitMQ中了？解决这个疑问的方式就是：RabbitMQ消息确认机制。
rocketMQ事务消息
Seati_的博客
04-22 342
*刷盘丢消息：**采用同步刷盘机制，如果是集群的话需要同步复制，也就是说保证消息持久化到每一台机器上才发送落盘成功的ACK。4.MQ收到事务执行结果，如果是commit就会把半事务消息设置为可发送状态，如果是rollback则把半事务消息删除掉。**消费者丢消息：**消费者执行完业务逻辑，再反馈Broker说消费成功，这样来保证消费阶段不丢消息。3.此时MQ不会把半事务消息推送给消费者，此时生产者开启事务执行业务逻辑后，发送事务结果给MQ。6.消费者消费完会返回ACK,MQ就会把消费过的消息删掉。
RocketMQ源码分析----Consumer消费进度相关
菜鸟一名
12-28 1427
在Consumer消费的时候总有几个疑问： 消费完成后，这个消费进度存在哪里 消费完成后，还没保存消费进度就挂了，会不会导致重复消费 Consumer 消费进度保存 消费完成后，会返回一个ConsumeConcurrentlyStatus.CONSUME_SUCCESS告诉MQ消费成功，以MessageListener的consumeMessage为入口分析。 消费的时候，是以ConsumeR...
深入RocketMQ-消息原理篇
gelald的博客
09-20 874
本篇文章将图解并分析 RocketMQ 中重点的消息原理，循序渐进地揭开 RocketMQ 发送消息的面纱，希望可以帮助有需要的你。
云原生中间件RocketMQ-生产者核心解析、主从同步机制解析，生产者同步异步消息发送
write less , do more
07-31 3759
方法中通过定义了一个固定时间的定时任务，时间是10秒钟执行一次，当然前提条件是broker节点的角色是slave，而broker节点是master时，如果有定时任务会取消，因为master是不用同步元数据信息。4个方法的内容实际上就是封装了netty做rpc的调用，对不同的操作都会对应到一个code。WriteSocketService（内部类）写往到Slave节点的数据。ReadSocketService（内部类）读来自Slave节点的数据。如有收获欢迎点赞👍收藏💖关注✔️，您的鼓励是我最大的动力。...
RocketMQ 学习教程——（二）SpringBoot 集成 RocketMQ
赵士杰——成功并非一蹴而就，而是在持之以恒的努力中逐渐实现。
05-28 5195
RocketMQ 学习教程——（二）SpringBoot 集成 RocketMQ
SpringBoot使用rocketMq
weixin_39388918的博客
04-07 1921
SpringBoot使用rocketMq
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值