RocketMQ高手之路系列之九：RocketMQ之事务消息（二）

于 2024-04-18 03:06:08 发布
阅读量696 收藏 27
点赞数 17
分类专栏： 程序员 文章标签： java-rocketmq rocketmq java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84010107/article/details/137897561
版权

@Override

public TransactionSendResult sendMessageInTransaction(final Message msg,

final Object arg) throws MQClientException {

if (null == this.transactionListener) {

throw new MQClientException(“TransactionListener is null”, null);

}

return this.defaultMQProducerImpl.sendMessageInTransaction(msg, null, arg);

}

…

}

在DefaultMQProducerImpl中进行事务消息调用，关键步骤在代码中进行了标注，如下所示：

public class DefaultMQProducerImpl implements MQProducerInner {

…

public TransactionSendResult sendMessageInTransaction(final Message msg,

final LocalTransactionExecuter localTransactionExecuter, final Object arg)

throws MQClientException {

TransactionListener transactionListener = getCheckListener();

if (null == localTransactionExecuter && null == transactionListener) {

throw new MQClientException(“tranExecutor is null”, null);

}

//1、进行消息检测

Validators.checkMessage(msg, this.defaultMQProducer);

SendResult sendResult = null;

//2、设置事务消息

MessageAccessor.putProperty(msg, MessageConst.PROPERTY_TRANSACTION_PREPARED, “true”);

MessageAccessor.putProperty(msg, MessageConst.PROPERTY_PRODUCER_GROUP, this.defaultMQProducer.getProducerGroup());

try {

//3、同步发送事务消息

sendResult = this.send(msg);

} catch (Exception e) {

throw new MQClientException(“send message Exception”, e);

}

LocalTransactionState localTransactionState = LocalTransactionState.UNKNOW;

Throwable localException = null;

switch (sendResult.getSendStatus()) {

case SEND_OK: {

try {

if (sendResult.getTransactionId() != null) {

msg.putUserProperty(“transactionId”, sendResult.getTransactionId());

}

String transactionId = msg.getProperty(MessageConst.PROPERTY_UNIQ_CLIENT_MESSAGE_ID_KEYIDX);

//4、发送成功，设置transactionId

if (null != transactionId && !“”.equals(transactionId)) {

msg.setTransactionId(transactionId);

}

if (null != localTransactionExecuter) {

localTransactionState = localTransactionExecuter.executeLocalTransactionBranch(msg, arg);

} else if (transactionListener != null) {

log.debug(“Used new transaction API”);

//5、执行本地事务，获取本地事务执行状态

localTransactionState = transactionListener.executeLocalTransaction(msg, arg);

}

if (null == localTransactionState) {

localTransactionState = LocalTransactionState.UNKNOW;

}

if (localTransactionState != LocalTransactionState.COMMIT_MESSAGE) {

log.info(“executeLocalTransactionBranch return {}”, localTransactionState);

log.info(msg.toString());

}

} catch (Throwable e) {

log.info(“executeLocalTransactionBranch exception”, e);

log.info(msg.toString());

localException = e;

}

}

break;

case FLUSH_DISK_TIMEOUT:

case FLUSH_SLAVE_TIMEOUT:

case SLAVE_NOT_AVAILABLE:

localTransactionState = LocalTransactionState.ROLLBACK_MESSAGE;

break;

default:

break;

}

try {

//6、更具本地事务执行状态，执行半消息的提交或者回滚

this.endTransaction(sendResult, localTransactionState, localException);

} catch (Exception e) {

log.warn("local transaction execute " + localTransactionState + “, but end broker transaction failed”, e);

}

TransactionSendResult transactionSendResult = new TransactionSendResult();

transactionSendResult.setSendStatus(sendResult.getSendStatus());

transactionSendResult.setMessageQueue(sendResult.getMessageQueue());

transactionSendResult.setMsgId(sendResult.getMsgId());

transactionSendResult.setQueueOffset(sendResult.getQueueOffset());

transactionSendResult.setTransactionId(sendResult.getTransactionId());

transactionSendResult.setLocalTransactionState(localTransactionState);

return transactionSendResult;

}

…

}

为了方便童鞋们理解，特地将关键步骤提取成了处理流程，大致的交互如下所示：

在这里插入图片描述

2、事务消息发送

在消息的发送过程中，实际调用到了DefaultMQProducerImpl的sendKernelImpl方法进行消息发送。

在这里插入图片描述

在消息发送过程中，对消息的属性进行判断，如果TRAN_MSG为true，则消息属性设置sysFlag 为TRANSACTION_PREPARED_TYPE，将消息类型设置为办消息类型。

final String tranMsg = msg.getProperty(MessageConst.PROPERTY_TRANSACTION_PREPARED);

if (tranMsg != null && Boolean.parseBoolean(tranMsg)) {

sysFlag |= MessageSysFlag.TRANSACTION_PREPARED_TYPE;

}

…

String isTrans = msg.getProperty(MessageConst.PROPERTY_TRANSACTION_PREPARED);

if (isTrans != null && isTrans.equals(“true”)) {

context.setMsgType(MessageType.Trans_Msg_Half);

}

3、事务消息存储

client端进行消息发送之后，broker server端接收到信息。在TransactionalMessageBridge 进行事务消息的处理，如下所示：

public class TransactionalMessageBridge {

…

public PutMessageResult putHalfMessage(MessageExtBrokerInner messageInner) {

return store.putMessage(parseHalfMessageInner(messageInner));

}

private MessageExtBrokerInner parseHalfMessageInner(MessageExtBrokerInner msgInner) {

MessageAccessor.putProperty(msgInner, MessageConst.PROPERTY_REAL_TOPIC, msgInner.getTopic());

MessageAccessor.putProperty(msgInner, MessageConst.PROPERTY_REAL_QUEUE_ID,

String.valueOf(msgInner.getQueueId()));

msgInner.setSysFlag(

MessageSysFlag.resetTransactionValue(msgInner.getSysFlag(), MessageSysFlag.TRANSACTION_NOT_TYPE));

//设置消息的topic为RMQ_SYS_TRANS_HALF_TOPIC

msgInner.setTopic(TransactionalMessageUtil.buildHalfTopic());

//设置queueId为0

msgInner.setQueueId(0);

msgInner.setPropertiesString(MessageDecoder.messageProperties2String(msgInner.getProperties()));

return msgInner;

}

}

…

我们可以看到Broker端将事务消息统一设置topic为RMQ_SYS_TRANS_HALF_TOPIC，将消息投递到同一队列中。然后进行消息的存储操作，比如写入CommitLog以及ConsumerQueue中，此处不再展开，后续对于消息的存储进行源码分析的时候再进行详细的阐述。

4、事务消息后置处理

在事务消息发送过后，更具事务消息的发送情况决定该消息进行提交还是进行回滚。该部分主要逻辑在如下代码中实现：

public void endTransaction(

final SendResult sendResult,

final LocalTransactionState localTransactionState,

final Throwable localException) throws RemotingException, MQBrokerException, InterruptedException, UnknownHostException {

final MessageId id;

//从broker返回的信息中获取half消息的offset

if (sendResult.getOffsetMsgId() != null) {

id = MessageDecoder.decodeMessageId(sendResult.getOffsetMsgId());

} else {

id = MessageDecoder.decodeMessageId(sendResult.getMsgId());

}

String transactionId = sendResult.getTransactionId();

final String brokerAddr = this.mQClientFactory.findBrokerAddressInPublish(sendResult.getMessageQueue().getBrokerName());

EndTransactionRequestHeader requestHeader = new EndTransactionRequestHeader();

// 将transactionId和offset发送给broker，以便于broker查找half消息位置

requestHeader.setTransactionId(transactionId);

requestHeader.setCommitLogOffset(id.getOffset());

//根据本地事务执行状态进行判断

switch (localTransactionState) {

//本地事务成功，提交半消息

case COMMIT_MESSAGE:

requestHeader.setCommitOrRollback(MessageSysFlag.TRANSACTION_COMMIT_TYPE);

break;

//回滚半消息

case ROLLBACK_MESSAGE:

requestHeader.setCommitOrRollback(MessageSysFlag.TRANSACTION_ROLLBACK_TYPE);

break;

case UNKNOW:

requestHeader.setCommitOrRollback(MessageSysFlag.TRANSACTION_NOT_TYPE);

break;

default:

break;

}

requestHeader.setProducerGroup(this.defaultMQProducer.getProducerGroup());

requestHeader.setTranStateTableOffset(sendResult.getQueueOffset());

requestHeader.setMsgId(sendResult.getMsgId());

String remark = localException != null ? ("executeLocalTransactionBranch exception: " + localException.toString()) : null;

//onway形式发送，不会等待返回

this.mQClientFactory.getMQClientAPIImpl().endTransactionOneway(brokerAddr, requestHeader, remark,

this.defaultMQProducer.getSendMsgTimeout());

}

消息发送之后，broker端处理收到的事务消息操作步骤，主要在EndTransactionProcessor进行处理，具体代码如下所示：

public class EndTransactionProcessor implements NettyRequestProcessor {

…

@Override

public RemotingCommand processRequest(ChannelHandlerContext ctx, RemotingCommand request) throws

RemotingCommandException {

final RemotingCommand response = RemotingCommand.createResponseCommand(null);

final EndTransactionRequestHeader requestHeader =

(EndTransactionRequestHeader)request.decodeCommandCustomHeader(EndTransactionRequestHeader.class);

LOGGER.info(“Transaction request:{}”, requestHeader);

if (BrokerRole.SLAVE == brokerController.getMessageStoreConfig().getBrokerRole()) {

response.setCode(ResponseCode.SLAVE_NOT_AVAILABLE);

LOGGER.warn("Message store is slave mode, so end transaction is forbidden. ");

return response;

}

if (requestHeader.getFromTransactionCheck()) {

switch (requestHeader.getCommitOrRollback()) {

case MessageSysFlag.TRANSACTION_NOT_TYPE: {

LOGGER.warn(“Check producer[{}] transaction state, but it’s pending status.”

  • “RequestHeader: {} Remark: {}”,

RemotingHelper.parseChannelRemoteAddr(ctx.channel()),

requestHeader.toString(),

request.getRemark());

return null;

}

case MessageSysFlag.TRANSACTION_COMMIT_TYPE: {

LOGGER.warn(“Check producer[{}] transaction state, the producer commit the message.”

  • “RequestHeader: {} Remark: {}”,

RemotingHelper.parseChannelRemoteAddr(ctx.channel()),

requestHeader.toString(),

request.getRemark());

break;

}

case MessageSysFlag.TRANSACTION_ROLLBACK_TYPE: {

LOGGER.warn(“Check producer[{}] transaction state, the producer rollback the message.”

  • “RequestHeader: {} Remark: {}”,

RemotingHelper.parseChannelRemoteAddr(ctx.channel()),

requestHeader.toString(),

request.getRemark());

break;

}

default:

return null;

}

} else {

switch (requestHeader.getCommitOrRollback()) {

case MessageSysFlag.TRANSACTION_NOT_TYPE: {

LOGGER.warn(“The producer[{}] end transaction in sending message, and it’s pending status.”

  • “RequestHeader: {} Remark: {}”,

RemotingHelper.parseChannelRemoteAddr(ctx.channel()),

requestHeader.toString(),

request.getRemark());

return null;

}

case MessageSysFlag.TRANSACTION_COMMIT_TYPE: {

break;

}

case MessageSysFlag.TRANSACTION_ROLLBACK_TYPE: {

LOGGER.warn(“The producer[{}] end transaction in sending message, rollback the message.”

  • “RequestHeader: {} Remark: {}”,

RemotingHelper.parseChannelRemoteAddr(ctx.channel()),

requestHeader.toString(),

request.getRemark());

break;

}

default:

return null;

}

}

OperationResult result = new OperationResult();

if (MessageSysFlag.TRANSACTION_COMMIT_TYPE == requestHeader.getCommitOrRollback()) {

result = this.brokerController.getTransactionalMessageService().commitMessage(requestHeader);

if (result.getResponseCode() == ResponseCode.SUCCESS) {

RemotingCommand res = checkPrepareMessage(result.getPrepareMessage(), requestHeader);

if (res.getCode() == ResponseCode.SUCCESS) {

MessageExtBrokerInner msgInner = endMessageTransaction(result.getPrepareMessage());

msgInner.setSysFlag(MessageSysFlag.resetTransactionValue(msgInner.getSysFlag(), requestHeader.getCommitOrRollback()));

msgInner.setQueueOffset(requestHeader.getTranStateTableOffset());

msgInner.setPreparedTransactionOffset(requestHeader.getCommitLogOffset());

msgInner.setStoreTimestamp(result.getPrepareMessage().getStoreTimestamp());

RemotingCommand sendResult = sendFinalMessage(msgInner);

if (sendResult.getCode() == ResponseCode.SUCCESS) {

this.brokerController.getTransactionalMessageService().deletePrepareMessage(result.getPrepareMessage());

}

return sendResult;

}

return res;

}

} else if (MessageSysFlag.TRANSACTION_ROLLBACK_TYPE == requestHeader.getCommitOrRollback()) {

result = this.brokerController.getTransactionalMessageService().rollbackMessage(requestHeader);

if (result.getResponseCode() == ResponseCode.SUCCESS) {

RemotingCommand res = checkPrepareMessage(result.getPrepareMessage(), requestHeader);

if (res.getCode() == ResponseCode.SUCCESS) {

this.brokerController.getTransactionalMessageService().deletePrepareMessage(result.getPrepareMessage());

}

return res;

}

}

response.setCode(result.getResponseCode());

response.setRemark(result.getResponseRemark());

return response;

}

…

}

5、本地事务状态回查

通过上述的代码分析可知，事务消息的提交和回滚操作是不等待消息响应的，所以说发送方并不会根据消息发送情况进行后续的处理。为了解决这一问题，客户端需要提供本地事务状态回查接口，这样Broker可以定时检查未处理的半消息对应的本地事务到底是执行成功还是执行失败。实现在TransactionalMessageCheckService中，如下所示：

public class TransactionalMessageCheckService extends ServiceThread {

…

@Override

protected void onWaitEnd() {

//获取transactionTimeOut参数

long timeout = brokerController.getBrokerConfig().getTransactionTimeOut();

//获取最大检测次数

int checkMax = brokerController.getBrokerConfig().getTransactionCheckMax();

long begin = System.currentTimeMillis();

log.info(“Begin to check prepare message, begin time:{}”, begin);

this.brokerController.getTransactionalMessageService().check(timeout, checkMax, this.brokerController.getTransactionalMessageCheckListener());

log.info(“End to check prepare message, consumed time:{}”, System.currentTimeMillis() - begin);

}

}

具体的检查流程在TransactionalMessageServiceImpl中的check方法中，如下所示：
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。img

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

img

我的面试宝典：一线互联网大厂Java核心面试题库

以下是我个人的一些做法，希望可以给各位提供一些帮助：

整理了很长一段时间，拿来复习面试刷题非常合适，其中包括了Java基础、异常、集合、并发编程、JVM、Spring全家桶、MyBatis、Redis、数据库、中间件MQ、Dubbo、Linux、Tomcat、ZooKeeper、Netty等等，且还会持续的更新…可star一下！

image

283页的Java进阶核心pdf文档

Java部分：Java基础，集合，并发，多线程，JVM，设计模式

数据结构算法：Java算法，数据结构

开源框架部分：Spring，MyBatis，MVC，netty，tomcat

分布式部分：架构设计，Redis缓存，Zookeeper，kafka，RabbitMQ，负载均衡等

微服务部分：SpringBoot，SpringCloud，Dubbo，Docker

image

还有源码相关的阅读学习

image

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
" alt=“img” style=“zoom: 33%;” />

我的面试宝典：一线互联网大厂Java核心面试题库

以下是我个人的一些做法，希望可以给各位提供一些帮助：

整理了很长一段时间，拿来复习面试刷题非常合适，其中包括了Java基础、异常、集合、并发编程、JVM、Spring全家桶、MyBatis、Redis、数据库、中间件MQ、Dubbo、Linux、Tomcat、ZooKeeper、Netty等等，且还会持续的更新…可star一下！

[外链图片转存中…(img-iWQ2fLon-1713380756941)]

283页的Java进阶核心pdf文档

Java部分：Java基础，集合，并发，多线程，JVM，设计模式

数据结构算法：Java算法，数据结构

开源框架部分：Spring，MyBatis，MVC，netty，tomcat

分布式部分：架构设计，Redis缓存，Zookeeper，kafka，RabbitMQ，负载均衡等

微服务部分：SpringBoot，SpringCloud，Dubbo，Docker

[外链图片转存中…(img-ImcsKeOL-1713380756942)]

还有源码相关的阅读学习

[外链图片转存中…(img-wyj22elc-1713380756942)]

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！

2401_84010107
关注
  • 17
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《使用RocketMQ 做Spring Cloud异步场景分布式事务》
公众号【Java大蜗牛】
09-23 407
作者：陶陶技术笔记 链接：https://www.cnblogs.com/zlt2000/p/11570917.html?utm_source=tuicool&utm_medium=referral 一、背景 在微服务架构中，我们常常使用异步化的手段来提升系统的吞吐量和解耦上下游，而构建异步架构最常用的手段就是使用 消息队列(MQ) ，那异步架构怎样才能实现数据...
spingboot-rocketmq事务消息
最新发布
09-16
3. **Check阶段**：RocketMQ后台会定期检查未确认的半消息，如果发现长时间未确认，会触发回查机制，询问生产者事务状态。 **注意事项** 1. **幂等性**：在处理事务消息时，需要确保消息处理的幂等性，防止重复消费...
RocketMQ - 如何实现事务消息
yang的博客
05-31 5011
事务消息的使用场景很多，比如在电商系统中用户下单后新增了订单记录，对应的商品库存需要减少。又例如红包业务，张三给李四发红包，张三的账户余额需要扣减，李四的账户余额需要增加，怎么保证张三账户扣减李四账户加钱呢？这些问题都是事务问题，可以简单理解为：一个表的数据更新后，如何保证另外一个表的数据也更新成功。如果使用同一个数据库实例，那么问题很简单，可以使用本地事务来解决，Spring的@Transactional注解就支持。消费事务消息与消费普通消息的代码是一样的，无需做任何修改。
RocketMQ源码分析实战 - RocketMQLocalTransactionListener
JavaEdge全是干货的技术号
12-08 4512
package org.apache.rocketmq.spring.core; import org.springframework.messaging.Message; public interface RocketMQLocalTransactionListener { // 用来执行本地事务 RocketMQLocalTransactionState executeLocal...
@RocketMQTransactionListener(txProducerGroup = “myTransactionGroup“)问题
prprprll的博客
04-19 1419
rocketmq-spring-boot-starter 2.1.0 事务消息 txProducerGroup 移除解读
RocketMQ事务消息思路
王鹏鹏-软件研发工程师
09-04 405
通过消息队列 RocketMQ 事务消息，能达到分布式事务的最终一致。 ​ 模拟A账户转账给B账户操作，这个分布式事务有两个子事务 子事务A：AReduceTransaction（）代表A账户扣款 子事务B：BIncreaseTransaction() 代表B账户收款 业务服务器实例一 一：向消息队列服务器发送半消息（半消息无法被消费），如果收到消息队列服务器的ACK代表发送成功，则执行本地事务，（AReduceTransaction），若本地事务执行成功，会通知消息队列服务器将半消息转为正常消息（可以
rocketmq源码分析：事务监听器（TransactionListenser）、消费端(MQConsumer)、负载均衡(RebalanceImpl)
mask哥
06-23 1195
1.事务监听器的实现原理（TransactionListenser） 本地事务消息的状态（LocalTransactionState）：提交消息、回滚消息、未知 2.RocketMQ 消费者实现原理（MQConsumer） 消费者获取消息提供了pull和push MQAdmin：提供了创建主题、检索消息偏移量、获取最早存储的消息时间、根据消息id查找消息、 消息模型（MessageModel）分为：广播和集群 ...
RocketMq事务消息发送代码流程详解
08-18
RocketMq是一种流行的开源消息队列系统，事务消息是其核心功能之一。事务消息发送代码流程详解是指在RocketMq中实现事务消息发送的整个过程。下面我们将详细介绍RocketMq事务消息发送代码流程详解。 一、RocketMq...
RocketMQ之去重操作
03-03
之前聊过一个问题，RocketMQ的设计上，是不考虑消息去重的问题，即不考虑消息是否会重复的消费的问题，而是将这个问题抛给业务端自己去处理幂等的问题。作为RocketMQ的使用者，现在去讨论RocketMQ为何不支持消息去重...
RocketMQ消息丢失解决方案：事务消息.docx
10-26
RocketMQ 消息丢失解决方案：事务消息 在本文中，我们将讨论如何解决 RocketMQ 中的消息丢失问题，特别是在生产者发送消息到 MQ 过程中的消息丢失问题。我们将介绍 RocketMQ 的事务消息机制，如何使用事务消息来...
RocketMQ事务消息机制
zsh2050的专栏
04-30 4616
RocketMQ提供了事务消息，通过事务消息就能达到分布式事务的最终一致，从而实现了可靠消息服务。 一、事务消息的实现步骤 事务消息发送步骤： 1. 发送方将半事务消息发送至RocketMQ服务端。 2. RocketMQ服务端将消息持久化之后，向发送方返回Ack确认消息已经发送成功。由于消息为半事务消息，在未收到生产者对该消息的二次确认前，此消息被标记成“暂不能投递”状态。 3. 发送方开始执行本地事务逻辑。 4. 发送方根据本地事务执行结果向服务端提交二次确认（Commit 或是 Rollbac
SpringCloud集成RocketMQ实现事务消息方案
热门推荐
传智燕青
09-01 3万+
前边的话 当前SpringCloud作为微服务开发的首选开源方案提供了完善的微服务开发技术套件，不过针对分布式领域的难题–分布式事务控制并没有成熟的方案，本篇将介绍作为柔性事务控制的优秀方案RocketMQ的使用原理和方法。 通过本案例的学习，掌握SpringCloud集成RocketMQ事务分布式事务控制的方法。 RocketMQ事务消息方案 RocketMQ 是一个来自阿里巴巴的分布式消息中间...
深入理解RocketMQ事务源码--TransactionMQProducer、TransactionListener
daobuxinzi的博客
02-17 987
前言 上篇文章，介绍了RocketMQ消息类型支持事务消息，常见用在分布式系统中，保证数据的一致性。接下来一起去走进 TransactionMQProducer、TransactionListener俩个核心类 一.基于apache-rocketmq事务消息的实现 （1） pom.xml配置 <dependency> <groupId>org.springframework.boot</groupId> &...
RocketMQ 事务消息
chenbin1991smile的博客
02-13 371
RocketMQ 官方发布了 4.3.0 版本，此版本解决了 RocketMQ 对事务的支持，这一重大更新对 RocketMQ 至关重要 。 本章将基于 RocketMQ 官方最新 4.3.0 版本，对其事务消息的实现原理进行深入探讨。 主要内容如下 。 ·事务消息实现思想 ·事务消息发送流程 ·事务消息提交或回滚 ·事务消息回查事务状态 1 事务消息实现思想 RocketMQ 事务消息的实现原理基于两阶段提交和定时事务状态回查来决定消息最终是提交还是回滚，交互设计如图 8-1 所示 。 1 ）应用程序在事
RocketMQ使用事务消息
LZJLZJLZJLZJLZJLZJ的专栏
12-18 1600
目录说明原理事务消息处理流程生产端消费端 说明 事务消息： 1、不支持延时消息和批量消息 2、如果消息没有及时提交，默认check 15次，可以通过Broker的transactionCheckMax参数配置次数。 如果超时15次依然没有得到明确结果，将会打印异常信息，具体的处理策略可以通过复写AbstractTransactionCheckListener类实现 3、每次check的时间间隔可以通过Broker的transactionTimeout配置，也可以在消息中增加CHECK_IMMUNITY_TI
RocketMQ实战(3) -事务消息
qq_33449307的博客
10-16 330
RocketMQ实战(3) -事务消息 干干净净没有故事,一个酷字贯穿一生。 springBoot快速整合rabbitMQ。话不多少，上才艺~ 1.生产者方面 1.1 定义监听器------执行本地事务和事务会查： @RocketMQTransactionListener @Slf4j public class TransactionListener implements RocketMQLocalTransactionListener { @Override public RocketMQ
RocketMq事务消息个人理解以及集成springboot
evil_lrn的博客
11-26 1870
rocketMq发送事物消息究竟有什么用
ROCKETMQ事务消息原理
weixin_33697898的博客
12-20 393
2019独角兽企业重金招聘Python工程师标准>>> ...
rocketmq 组监听_Spring Boot整合RocketMQ之事务消息
06-08
好的，你的问题是 "rocketmq 组监听_Spring Boot整合RocketMQ之事务消息"。那么，我来为你解答。 在 RocketMQ 中，组监听是一种消费消息的方式。当有多个消费者需要消费同一类消息时，可以使用组监听。组监听中，每个消费者都会收到相同的消息，但只有其中一个消费者会实际消费该消息。这种方式可以提高消息的可靠性和可扩展性。 而在 Spring Boot 中，可以通过 RocketMQ 的事务消息来实现对消息的事务性处理。事务消息是指在消息发送和消息消费之间增加了一个事务协调器，用于协调消息的发送和消费操作，以保证消息的可靠性和一致性。 具体地，在 Spring Boot 中，可以使用 RocketMQ 的 TransactionListener 接口来实现事务消息的处理。该接口包括三个方法：executeLocalTransaction、checkLocalTransaction 和 executeTransaction。 其中，executeLocalTransaction 方法用于执行本地事务，checkLocalTransaction 方法用于检查本地事务的执行状态，而 executeTransaction 方法用于执行事务消息的发送和消费操作。通过使用这些方法，可以实现对 RocketMQ 事务消息的完整处理流程。 希望这个回答能够帮助到你，如果还有什么问题，可以继续提出来哦。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值