RocketMQ：消息ACK机制源码解析

最新推荐文章于 2024-09-20 10:49:38 发布
最新推荐文章于 2024-09-20 10:49:38 发布
阅读量7.9k 收藏 1
点赞数 4
分类专栏： RocketMQ 文章标签： java RocketMQ
又蠢又笨的懒羊羊程序猿
本文链接：https://blog.csdn.net/TaylorSwiftiiln/article/details/121438326
版权

消息消费进度

概述

消费者消费消息过程中，为了避免消息的重复消费，应将消息消费进度保存起来，当其他消费者再对消息进行消费时，读取已消费的消息偏移量，对之后的消息进行消费即可。

消息模式分为两种：

  • 集群模式：一条消息只能被一个消费者消费
  • 广播模式：一条消息被所有消费者都消费一次

广播模式下，消息被所有消费者消费，因此消息消费的进度可以跟消费端保存在一起，即本地保存。

集群模式下，消息只能被集群内的一个消费者消费，进度不能保存在消费端，否则会导致消息重复消费，因此集群模式下消息进度集中保存在Broker中。

消息进度存储接口

OffsetStore

public interface OffsetStore {
	//加载消息消费进度
    void load() throws MQClientException;

    //更新消费进度并保存在内存中
    void updateOffset(final MessageQueue mq, final long offset, final boolean increaseOnly);

	//从本地存储中获取消息消费进度
    long readOffset(final MessageQueue mq, final ReadOffsetType type);

	//保存所有消息消费进度-本地/远程
    void persistAll(final Set<MessageQueue> mqs);

    void persist(final MessageQueue mq);

 	//移除偏移量
    void removeOffset(MessageQueue mq);

    //根据Topic克隆一份消息队列消费进度缓存表
    Map<MessageQueue, Long> cloneOffsetTable(String topic);

   //更新消费进度到Broker
    void updateConsumeOffsetToBroker(MessageQueue mq, long offset, boolean isOneway) throws RemotingException,
        MQBrokerException, InterruptedException, MQClientException;
}

DefaultMQPushConsumerImpl#start

switch (this.defaultMQPushConsumer.getMessageModel()) {
    case BROADCASTING:
        //广播模式下 将消息消费进度存储到本地
        this.offsetStore = new LocalFileOffsetStore(this.mQClientFactory, this.defaultMQPushConsumer.getConsumerGroup());
        break;
    case CLUSTERING:
        //集群模式下 将消息消费的进度存储到远端Broker中
        this.offsetStore = new RemoteBrokerOffsetStore(this.mQClientFactory, this.defaultMQPushConsumer.getConsumerGroup());
        break;
    default:
        break;
}
this.defaultMQPushConsumer.setOffsetStore(this.offsetStore);

如上所示，根据消息消费模式的不同，会创建不同的OffsetStore对象。

广播模式消费进度存储(LocalFileOffsetStore)
public class LocalFileOffsetStore implements OffsetStore {
    //存储目录
    //消费者启动时-可以通过"-D rocketmq.client.localOffsetStoreDir=路径"来指定
    public final static String LOCAL_OFFSET_STORE_DIR = System.getProperty(
        "rocketmq.client.localOffsetStoreDir",
        System.getProperty("user.home") + File.separator + ".rocketmq_offsets");
    private final static InternalLogger log = ClientLogger.getLog();
    //MQ客户端
    private final MQClientInstance mQClientFactory;
    //消费组名
    private final String groupName;
    //存储路径
    private final String storePath;
    //以MessageQueue为键-消费偏移量为值的缓存表
    private ConcurrentMap<MessageQueue, AtomicLong> offsetTable =
        new ConcurrentHashMap<MessageQueue, AtomicLong>();
}

构造函数

public LocalFileOffsetStore(MQClientInstance mQClientFactory, String groupName) {
    this.mQClientFactory = mQClientFactory;
    this.groupName = groupName;
    //json格式存储
    this.storePath = LOCAL_OFFSET_STORE_DIR + File.separator +
        this.mQClientFactory.getClientId() + File.separator +
        this.groupName + File.separator +
        "offsets.json";
}

LocalFileOffsetStore#load

public void load() throws MQClientException {
    //从本地磁盘中进行读取json文件-并进行序列化封装转化为map
    OffsetSerializeWrapper offsetSerializeWrapper = this.readLocalOffset();
    if (offsetSerializeWrapper != null && offsetSerializeWrapper.getOffsetTable() != null) {
        //存入缓存表
        offsetTable.putAll(offsetSerializeWrapper.getOffsetTable());

        for (MessageQueue mq : offsetSerializeWrapper.getOffsetTable().keySet()) {
            AtomicLong offset = offsetSerializeWrapper.getOffsetTable().get(mq);
            log.info("load consumer's offset, {} {} {}",
                this.groupName,
                mq,
                offset.get());
        }
    }
}

public class OffsetSerializeWrapper extends RemotingSerializable {
    private ConcurrentMap<MessageQueue, AtomicLong> offsetTable =
        new ConcurrentHashMap<MessageQueue, AtomicLong>();
}

LocalFileOffsetStore#persistAll

public void persistAll(Set<MessageQueue> mqs) {
    if (null == mqs || mqs.isEmpty()) {
        return;
    }
	
    OffsetSerializeWrapper offsetSerializeWrapper = new OffsetSerializeWrapper();
    for (Map.Entry<MessageQueue, AtomicLong> entry : this.offsetTable.entrySet()) {
        if (mqs.contains(entry.getKey())) {
            AtomicLong offset = entry.getValue();
            //填充<消息队列-消费偏移量>缓存表
            offsetSerializeWrapper.getOffsetTable().put(entry.getKey(), offset);
        }
    }

    //转为json格式
    String jsonString = offsetSerializeWrapper.toJson(true);
    if (jsonString != null) {
        try {
            //jsonString->file->保存到storePath
            MixAll.string2File(jsonString, this.storePath);
        } catch (IOException e) {
            log.error("persistAll consumer offset Exception, " + this.storePath, e);
        }
    }
}

persistAll()的入口是MQClientInstance#startScheduledTask

MQClientInstance#startScheduledTask

this.scheduledExecutorService.scheduleAtFixedRate(new Runnable() {

    @Override
    public void run() {
        try {
            MQClientInstance.this.persistAllConsumerOffset();
        } catch (Exception e) {
            log.error("ScheduledTask persistAllConsumerOffset exception", e);
        }
    }
}, 1000 * 10, this.clientConfig.getPersistConsumerOffsetInterval(), TimeUnit.MILLISECONDS);

消费端启动后延迟10s开启该定时任务，每隔5s进行一次持久化。

MQClientInstance#persistAllConsumerOffset

Iterator<Entry<String, MQConsumerInner>> it = this.consumerTable.entrySet().iterator();
while (it.hasNext()) {
    Entry<String, MQConsumerInner> entry = it.next();
    MQConsumerInner impl = entry.getValue();
    impl.persistConsumerOffset();
}

DefaultMQPushConsumerImpl#persistConsumerOffset

try {
    this.makeSureStateOK();
    Set<MessageQueue> mqs = new HashSet<MessageQueue>();
    //获取重负载分配好的消息队列
    Set<MessageQueue> allocateMq = this.rebalanceImpl.getProcessQueueTable().keySet();
    mqs.addAll(allocateMq);
	//当前是LocalFileOffsetStore.persistAll
    this.offsetStore.persistAll(mqs);
} catch (Exception e) {
    log.error("group: " + this.defaultMQPushConsumer.getConsumerGroup() + " persistConsumerOffset exception", e);
}
集群模式消费进度存储(RemoteBrokerOffsetStore)

RemoteBrokerOffsetStore

private final static InternalLogger log = ClientLogger.getLog();
//MQ客户端实例-该实例被同一个JVM下的消费者和生产者共用
private final MQClientInstance mQClientFactory;
//消费组名
private final String groupName;
//以消息队列为键-消费偏移量为值的缓存表
private ConcurrentMap<MessageQueue, AtomicLong> offsetTable =
    new ConcurrentHashMap<MessageQueue, AtomicLong>();

RemoteBrokerOffsetStore#persistAll

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 {
                //更新消费偏移量到Broker
                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);
            }
        } 
    }
}

RemoteBrokerOffsetStore#updateConsumeOffsetToBroker

同步更新消息消费偏移量，如Master关闭，则更新到Slave。

//从MQ客户端中根据BrokerName获取消息队列对应的Broker
FindBrokerResult findBrokerResult = this.mQClientFactory.findBrokerAddressInAdmin(mq.getBrokerName());
if (null == findBrokerResult) {
    //根据Topic从NameServer更新路由信息
    this.mQClientFactory.updateTopicRouteInfoFromNameServer(mq.getTopic());
    //重新查找
    findBrokerResult = this.mQClientFactory.findBrokerAddressInAdmin(mq.getBrokerName());
}

if (findBrokerResult != null) {
    //封装消息消费队列更新请求头
    UpdateConsumerOffsetRequestHeader requestHeader = new UpdateConsumerOffsetRequestHeader();
    requestHeader.setTopic(mq.getTopic());			//主题信息
    requestHeader.setConsumerGroup(this.groupName);	 //消费者组
    requestHeader.setQueueId(mq.getQueueId());		//队列ID
    requestHeader.setCommitOffset(offset);			//消费偏移量

    if (isOneway) {
        //Oneway->根据Broker地址->发送请求将消费偏移量保存到Broker-超时时间默认为5s
        this.mQClientFactory.getMQClientAPIImpl().updateConsumerOffsetOneway(
            findBrokerResult.getBrokerAddr(), requestHeader, 1000 * 5);
    } else {
        this.mQClientFactory.getMQClientAPIImpl().updateConsumerOffset(
            findBrokerResult.getBrokerAddr(), requestHeader, 1000 * 5);
    }
} else {
    throw new MQClientException("The broker[" + mq.getBrokerName() + "] not exist", null);
}

RemoteBrokerOffsetStore#updateOffset

if (mq != null) {
    //从缓存中获取消息队列对应的偏移量
    AtomicLong offsetOld = this.offsetTable.get(mq);
    //为空
    if (null == offsetOld) {
        //将存入的offset存入内存中
        offsetOld = this.offsetTable.putIfAbsent(mq, new AtomicLong(offset));
    }
	//不为空->根据increaseOnly更新原先的offsetOld
    if (null != offsetOld) {
        if (increaseOnly) {
            MixAll.compareAndIncreaseOnly(offsetOld, offset);
        } else {
            offsetOld.set(offset);
        }
    }
}

RemoteBrokerOffsetStore#readOffset

public long readOffset(final MessageQueue mq,	//消息队列
                       final ReadOffsetType type) {	//读取偏移量类型
    if (mq != null) {
        switch (type) {
            case MEMORY_FIRST_THEN_STORE:
            //从内存中读取    
            case READ_FROM_MEMORY: {
                AtomicLong offset = this.offsetTable.get(mq);
                if (offset != null) {
                    return offset.get();
                } else if (ReadOffsetType.READ_FROM_MEMORY == type) {
                    return -1;
                }
            }
            //从Broker中读取    
            case READ_FROM_STORE: {
                try {
                    //从Broker中获取消费偏移量
                    long brokerOffset = this.fetchConsumeOffsetFromBroker(mq);
                    AtomicLong offset = new AtomicLong(brokerOffset);
                    //更新至内存中(map)
                    this.updateOffset(mq, offset.get(), false);
                    return brokerOffset;
                }
                // No offset in broker
                catch (MQBrokerException e) {
                    return -1;
                }
                //Other exceptions
                catch (Exception e) {
                    log.warn("fetchConsumeOffsetFromBroker exception, " + mq, e);
                    return -2;
                }
            }
            default:
                break;
        }
    }

RemoteBrokerOffsetStore#fetchConsumeOffsetFromBroker

//从MQ客户端实例中获取Boker信息
FindBrokerResult findBrokerResult = this.mQClientFactory.findBrokerAddressInAdmin(mq.getBrokerName());
if (null == findBrokerResult) {
	//从NameServer中更新Topic的路由信息
    this.mQClientFactory.updateTopicRouteInfoFromNameServer(mq.getTopic());
    //重新获取Broker
    findBrokerResult = this.mQClientFactory.findBrokerAddressInAdmin(mq.getBrokerName());
}

if (findBrokerResult != null) {
    //封装查询消费进度请求头
    QueryConsumerOffsetRequestHeader requestHeader = new QueryConsumerOffsetRequestHeader();
    requestHeader.setTopic(mq.getTopic());
    requestHeader.setConsumerGroup(this.groupName);
    requestHeader.setQueueId(mq.getQueueId());
	//带上请求头调用MQClientAPI到Broker中获取
    return this.mQClientFactory.getMQClientAPIImpl().queryConsumerOffset(
        findBrokerResult.getBrokerAddr(), requestHeader, 1000 * 5);
} else {
    throw new MQClientException("The broker[" + mq.getBrokerName() + "] not exist", null);
}

本文仅作为个人学习使用，如有不足或错误请指正！

又蠢又笨的懒羊羊程序猿
关注
专栏目录
RocketMQ消息ACK机制及消费进度管理
悟已往之不谏，知来者之可追
04-03 1572
保证消费成功 启动的时候从哪里消费 消息ACK机制 Ack卡进度解决方案
RocketMQ——ack机制保证消费成功
热门推荐
东天里的冬天
06-26 3万+
ACK简介 在实际使用RocketMQ的时候我们并不能保证每次发送的消息都刚好能被消费者一次性正常消费成功，可能会存在需要多次消费才能成功或者一直消费失败的情况，那作为发送者该做如何处理呢？ RocketMQ提供了ack机制，以保证消息能够被正常消费。发送者为了保证消息肯定消费成功，只有使用方明确表示消费成功，RocketMQ才会认为消息消费成功。中途断电，抛出异常等都不会认为成功——即都会重...
RocketMq详解：一、RocketMQ 介绍及基本概念
最新发布
qq_59961910的博客
09-20 3651
Name Server和ZooKeeper的作用大致是相同的，从宏观上来看，Name Server做的东西很少，就是保存一些运行数据，Name Server之间不互连，这就需要broker端连接所有的Name Server，运行数据的改动要发送到每一个Name Server来保证运行数据的一致性（这个一致性确实有点弱），这样就变成了Name Server很轻量级，但是broker端就要做更多的东西了。这种方式优点是数据与服务都没有单点问题，Master 宕机时消息无延迟，服务与数据的可用性非常高。
RocketMQ消息ACK机制
oliver486的博客
04-01 1万+
最详细的RocketMQ Ack机制分析
RocketMQ重试机制(ACK确认机制)
hi_bigguy的博客
08-10 1万+
今天我们来扒一扒RocketMQ重试机制的底裤，内容比较硬核，建议一键三联。哦不，走错片场了，建议点赞 + 收藏。 好嘞，咱们这就上车~ 以下只设计Consumer的重试机制，Producer比较简单，只是单纯的重发（当然还有故障转移机制啦），暂不讨论… 设计知识点 ACK 重试机制原理 死信队列（DLQ队列） 几个问题 消息重试是什么意思？ Consumer 消费消息分为集群模式(Cluster）、广播模式（Broadcast），两种模式都会进行消息重试吗？ 消息重试的策略是什么？ 消息重试的
源码分析RocketMQ之消息ACK机制（消费进度）
中间件兴趣圈
01-17 9398
1、消息消费进度概述 首先简要阐述一下消息消费进度： 消费者订阅消息消费队列（MessageQueue), 当生产者将消息负载发送到 MessageQueue 中时，消费订阅者开始消费消息，消息消费过程中，为了避免重复消费，需要一个地方存储消费进度（消费偏移量）。 消息模式主要分为集群模式、广播模式： 集群模式：一条消息被集群中任何一个消费者消费。 广播模式：每条消息都被每一个消费者消费...
RocketMQ入门实战及源码解析.7z
06-23
RocketMQ的源码解析可以帮助我们理解其内部机制，包括NameServer的注册与发现、Broker的消息存储与检索、Producer的发送逻辑、Consumer的消费策略等。通过阅读源码，可以学习到如何设计分布式系统、如何优化消息传递...
rocketmq 重复拉取消息_RocketMQ原理（4）——消息ACK机制及消费进度管理
weixin_39872872的博客
12-20 358
https://zhuanlan.zhihu.com/p/25140744 中剖析过，consumer的每个实例是靠队列分配来决定如何消费消息的。那么消费进度具体是如何管理的，又是如何保证消息成功消费的(RocketMQ有保证消息肯定消费成功的特性(失败则重试)？本文将详细解析消息具体是如何ack的，又是如何保证消费肯定成功的。由于以上工作所有的机制都实现在PushConsumer中，所以本文的原...
RocketMQ架构篇 - 事务消息
The Secret
03-10 808
本文介绍RocketMQ的事务消息。
MQ - RocketMQ底层原理和源码解析
m0_58477403的博客
06-24 207
RocketMQ底层原理和源码解析 本文的内容主要包括：MQ的对比和选型、RocketMQ原理、RocketMQ源码解析、事务消息。 Rocketmq性能压测客户端：https://github.com/Force-King/rocketmq-test 一、MQ的对比和选型 目前业界主要的消息中间件有：ActiveMQ、RabbitMQ、ZeroMQ、Kafka、MetaMQ、RocketMQ。其中开源的，社区比较活跃的是ActiveMQ、RabbitMQ、Kafka、RocketMQ。所以，我们做技术选型
RocketMQ源码：ACK机制及消费进度管理
2301_76607156的博客
03-30 1473
那么消费进度具体是如何管理的，又是如何保证消息成功消费的?由于以上工作所有的机制都实现在PushConsumer中，所以本文的原理均只适用于RocketMQ中的PushConsumer即Java客户端中的DefaultPushConsumer。上面两个问题的本质归结到一个那就是如何把这些数据持久化，在哪里持久化的问题。持久化的位置这就确定了这些数据加载的位置。如果是最上面的队列全部消费了那么序列化的就是7后面的消息。接着根据不同的消费模式来处理消费掉的信息和为消费的信息，对于未消费的信息重新提交延迟消费。
【RocketMQ】源码详解：ACK消息、消息重试、消费进度管理
博客
04-02 1138
消息消费失败,发送ack消息:org.apache.rocketmq.client.impl.consumer.ConsumeMessageConcurrentlyService#sendMessageBack。入口: org.apache.rocketmq.client.impl.consumer.ConsumeMessageConcurrentlyService#sendMessageBack。消息消费失败的情况下,会发送ack消息给broker, 发送的内容包括topic、偏移量、msgId等。
RocketMQ原理（4）——消息ACK机制及消费进度管理
guolong1983811的专栏
12-16 5823
https://zhuanlan.zhihu.com/p/25265380 consumer的每个实例是靠队列分配来决定如何消费消息的。那么消费进度具体是如何管理的，又是如何保证消息成功消费的（RocketMQ有保证消息肯定消费成功的特性（失败则重试）？ 本文将详细解析消息具体是如何ack的，又是如何保证消费肯定成功的。 由于以上工作所有的机制都实现在PushConsumer
RocketMQ源码分析之消息ACK机制（消费进度）
qq_33291299的博客
02-23 791
首先简要阐述一下消息消费进度：消费者订阅消息消费队列（MessageQueue), 当生产者将消息负载发送到 MessageQueue 中时，消费订阅者开始消费消息，消息消费过程中，为了避免重复消费，需要一个地方存储消费进度（消费偏移量）。广播模式，既然每条消息要被每一个消费者消费，则消费进度可以与消费者保存在一起，也就是本地保存，但由于集群模式下，一条消息只能被集群内的一个消费者消费，进度不能保存在消费端，只能集中保存在一个地方，比较合适的是在 Broker 端。
源码分析RocketMQ之broker-消息ACK机制
liangshf520的博客
08-27 685
源码分析RocketMQ之broker-消息ACK机制
rocketmq——关于消费的疑惑（ACK机制）
qq_35362055的博客
08-10 8994
rocketmq——关于消费的疑惑（ACK机制） 开个头 消息的数据结构在Producer端是Message，因为到了Broker，Broker会给消息加字段，就成了MessageExt，MessageExt继承自Message rocketmq在MessageListenerConcurrently接口的consumeMessage的参数List是一个消息列表 consumeMessa...
RocketMQ——消息ACK机制及消费进度管理
linuxheik的专栏
03-16 1万+
RocketMQ——消息ACK机制及消费进度管理2017-01-25 WED 20:49RokectMQ——水平扩展及负载均衡详解 中剖析过，consumer的每个实例是靠队列分配来决定如何消费消息的。那么消费进度具体是如何管理的，又是如何保证消息成功消费的?（RocketMQ有保证消息肯定消费成功的特性,失败则重试）？本文将详细解析消息具体是如何ack的，又是如何保证消费肯定成功的。由于以上工作...
ActiveMQ消息传输与ACK机制深度解析
"本文详细介绍了ActiveMQ的消息传送机制和ACK机制，包括Producer和Consumer的角色，以及broker在其中的作用。文中还提到了消息生命周期、优化ACK选项和预获取策略，旨在帮助开发者理解ActiveMQ如何确保消息的可靠...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

又蠢又笨的懒羊羊程序猿

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

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

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

打赏作者

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

抵扣说明：

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

余额充值