RocketMQ源码解析十三（事务消息流程）

港控/mmm° 2022-09-12 07:47 4阅读 0赞

> **RocketMQ版本4.6.0，记录自己看源码的过程**

## 代码示例 ##

@Configuration
    public class UserProducerConfiguration { 
    
        @Autowired
        private UserService userService;
    
        @Bean
        public TransactionMQProducer producer() throws MQClientException { 
            TransactionMQProducer producer = new TransactionMQProducer("user_producer_group");
            producer.setNamesrvAddr("localhost:9876");
            producer.setTransactionListener(new TransactionListener() { 
                @Override
                public LocalTransactionState executeLocalTransaction(Message message, Object o) { 
                    // 根据本地事务执行成与否判断 事务消息是否需要commit与 rollback
                    ObjectMapper objectMapper = new ObjectMapper();
                    LocalTransactionState state;
                    try { 
                        User user = objectMapper.readValue(message.getBody(), User.class);
                        userService.insert(user);
                        state = LocalTransactionState.COMMIT_MESSAGE;
                    } catch (Exception e) { 
                        e.printStackTrace();
                        state = LocalTransactionState.ROLLBACK_MESSAGE;
                    }
                    return state;
                }
    
                @Override
                public LocalTransactionState checkLocalTransaction(MessageExt messageExt) { 
                    ObjectMapper objectMapper = new ObjectMapper();
                    LocalTransactionState state = LocalTransactionState.UNKNOW;
                    User user;
                    try { 
                        user = objectMapper.readValue(messageExt.getBody(), User.class);
                    } catch (IOException e) { 
                        e.printStackTrace();
                        return state;
                    }
                    try { 
                        // 查询数据库是否有这条记录
                        user = userService.select(user.getId());
    
                        if (user != null) { 
                            state = LocalTransactionState.COMMIT_MESSAGE;
                        } else { 
                            state = LocalTransactionState.ROLLBACK_MESSAGE;
                        }
                    } catch (Exception e) { 
                        e.printStackTrace();
                    }
                    return state;
                }
            });
            producer.start();
            return producer;
        }
    }

@Service
    public class UserServiceImpl implements UserService { 
    
        @Autowired
        private UserMapper userMapper;
        @Autowired
        private TransactionMQProducer producer;
    
        @Override
        public void insert() throws Exception { 
            User user = User.builder().id(UUID.randomUUID().toString()).name("test").build();
            Message msg = new Message("userTopic", "tagA", user.getId(),
                    new ObjectMapper().writeValueAsString(user).getBytes(RemotingHelper.DEFAULT_CHARSET));
            // 发送事务消息
            SendResult sendResult = producer.sendMessageInTransaction(msg, null);
        }
    
        @Override
        public boolean insert(User user) { 
            return userMapper.insert(user);
        }
    
        @Override
        public User select(String id) { 
            return userMapper.select(id);
        }
    
        public boolean update(User user) { 
            return userMapper.update(user);
        }
    }

## 事务消息设计思想 ##

在执行本地数据落库之前，会由生产者先发送一条半消息（prepare，这条消息对消费者是不可见的），发送成功表示MQ是可用的，然后会回调生产者的事件监听程序，执行本地事务使数据落库，之后根据本地事务执行情况向MQ发送commit或rollback，提交后，消费者就可以消费到消息了。  
如果在commit或rollback时失败了，MQ服务器会开启一个定时任务，每隔60s会回查那些prepare状态下的消息，检查本地事务是否成功，根据状态再次发送commit或rollback，保证数据的一致性。  
![在这里插入图片描述][b36990483ff31863bc915439a8ab868b.png_pic_center]

## 事务消息发送流程 ##

**DefaultMQProducerImpl**

/** * 发送事务消息 */
    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);
        }
    
        // 忽略延时
        if (msg.getDelayTimeLevel() != 0) { 
            MessageAccessor.clearProperty(msg, MessageConst.PROPERTY_DELAY_TIME_LEVEL);
        }
    
        Validators.checkMessage(msg, this.defaultMQProducer);
    
        SendResult sendResult = null;
        // 事务消息属性设为true
        MessageAccessor.putProperty(msg, MessageConst.PROPERTY_TRANSACTION_PREPARED, "true");
        MessageAccessor.putProperty(msg, MessageConst.PROPERTY_PRODUCER_GROUP, this.defaultMQProducer.getProducerGroup());
        try { 
            // 同步发送，跟发送普通消息一样
            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);
                    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");
                        // 执行本地事务
                        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;
            // 刷盘或同步slave失败则需要回滚，不会执行本地事务
            case FLUSH_DISK_TIMEOUT:
            case FLUSH_SLAVE_TIMEOUT:
            case SLAVE_NOT_AVAILABLE:
                localTransactionState = LocalTransactionState.ROLLBACK_MESSAGE;
                break;
            default:
                break;
        }
    
        try { 
            // 结束事务，根据本地事务决定消息事务是提交还是回滚，单向请求
            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;
    }

可以看到发送的逻辑也是用发送普通消息的逻辑，只是在发送之前会先清除延时以及设置事务消息属性。  
然后根据发送的结果进行分别处理：  
1、如果发送成功，则执行监听器中的本地事务方法executeLocalTransaction，返回本地事务状态。

**按我的理解，如果executeLocalTransaction方法，或者说执行发送事务消息的方法与本地事务（service中的方法）处于同一个事务内，则不管本地事务成功与否，都应该返回UNKNOW，交由broker回查来决定提交或回滚。因为同一个事务内，如果本地事务执行成功，但还未提交，向broker发送提交确认完后该机器宕机了，此时本地事务回滚，但发出去的确认消息无法收回，消费者会收到消息，导致数据不一致。所以发送UNKNOW，由broker来回查，没问题，消息确认，有问题，消息回滚。  
如果没有处于同一个事务内，则直接根据本地事务的执行情况返回COMMIT\_MESSAGE或ROLLBACK\_MESSAGE**

2、如果发送失败，则将本地事务状态设置为ROLLBACK\_MESSAGE。  
最后结束事务，根据上面的本地事务决定消息事务是提交还是回滚，单向请求。

接着看下broker端如果处理prepare状态的半消息。

Broker处理事务消息也是用SendMessageProcessor处理器处理。

/** * 处理发送消息请求 */
    private RemotingCommand sendMessage(final ChannelHandlerContext ctx,
                                        final RemotingCommand request,
                                        final SendMessageContext sendMessageContext,
                                        final SendMessageRequestHeader requestHeader) throws RemotingCommandException { 
    
        // 省略。。。
    
        // 校验是否不允许发送事务消息
        if (traFlag != null && Boolean.parseBoolean(traFlag)) { 
            // 不允许发送事务消息
            if (this.brokerController.getBrokerConfig().isRejectTransactionMessage()) { 
                response.setCode(ResponseCode.NO_PERMISSION);
                response.setRemark(
                    "the broker[" + this.brokerController.getBrokerConfig().getBrokerIP1()
                        + "] sending transaction message is forbidden");
                return response;
            }
            // 处理事务消息
            putMessageResult = this.brokerController.getTransactionalMessageService().prepareMessage(msgInner);
        } else { 
            // 使用MessageStore组件将消息存储在本地文件，只存储CommitLog文件，
            // ConsumerQueue文件和IndexFile文件会由后台线程异步存储
            putMessageResult = this.brokerController.getMessageStore().putMessage(msgInner);
        }
    
        // 处理消息存储结果
        return handlePutMessageResult(putMessageResult, response, request, msgInner, responseHeader, sendMessageContext, ctx, queueIdInt);
    
    }

broker会判断是否是事务消息，事务消息则由事务消息服务处理。  
**TransactionalMessageServiceImpl**

@Override
    public PutMessageResult prepareMessage(MessageExtBrokerInner messageInner) { 
        return transactionalMessageBridge.putHalfMessage(messageInner);
    }

**TransactionalMessageBridge**

public PutMessageResult putHalfMessage(MessageExtBrokerInner messageInner) { 
        // 将消息存入事务消息专属的topic中，存储操作跟普通消息一样
        return store.putMessage(parseHalfMessageInner(messageInner));
    }
    
    /** * 转换事务消息，将原topic和queueId放到属性中，替换为topic为RMQ_SYS_TRANS_HALF_TOPIC， * queueId为0 */
    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));
        msgInner.setTopic(TransactionalMessageUtil.buildHalfTopic());
        msgInner.setQueueId(0);
        msgInner.setPropertiesString(MessageDecoder.messageProperties2String(msgInner.getProperties()));
        return msgInner;
    }

这里是事务消息与非事务消息发送流程的主要区别，如果是事务消息则备份消息的原主题与原消息消费队列，然后将主题变更为RMQ\_ SYS\_ TRANS\_ HALF\_ TOPIC，消费队列变更为0，然后消息按照普通消息存储在commitlog文件进而转发到RMQ\_SYS\_TRANS\_HALF\_ TOPIC主题对应的消息消费队列。也就是说，事务消息在未提交之前并不会存人消息原有主题，自然也不会被消费者消费。——摘自《RocketMQ技术内幕》

## 提交或回滚消息 ##

上面说到，半消息发送完成后，会根据发送状态执行本地事务，再根据本地事务状态结束事务（提交或回滚消息）。  
**DefaultMQProducerImpl**

public void endTransaction(
        final SendResult sendResult,
        final LocalTransactionState localTransactionState,
        final Throwable localException) throws RemotingException, MQBrokerException, InterruptedException, UnknownHostException { 
        final MessageId id;
        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();
        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;
        // 提交或回滚或不处理事务消息
        this.mQClientFactory.getMQClientAPIImpl().endTransactionOneway(brokerAddr, requestHeader, remark,
            this.defaultMQProducer.getSendMsgTimeout());
    }

Broker端处理结束事务的处理器是EndTransactionProcessor

@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.debug("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;
        }
    
        // 省略不重要代码。。
        
        OperationResult result = new OperationResult();
        // 提交消息
        if (MessageSysFlag.TRANSACTION_COMMIT_TYPE == requestHeader.getCommitOrRollback()) { 
            // 根据requestHeader中的物理偏移量从commitLog中取出prepared状态的消息
            result = this.brokerController.getTransactionalMessageService().commitMessage(requestHeader);
            if (result.getResponseCode() == ResponseCode.SUCCESS) { 
                RemotingCommand res = checkPrepareMessage(result.getPrepareMessage(), requestHeader);
                if (res.getCode() == ResponseCode.SUCCESS) { 
                    // 根据PrepareMessage复制一份消息，topic为原主题
                    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) { 
                        // 删除PrepareMessage，表示消息处理过了
                        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) { 
                    // 删除PrepareMessage，表示消息处理过了
                    this.brokerController.getTransactionalMessageService().deletePrepareMessage(result.getPrepareMessage());
                }
                return res;
            }
        }
        response.setCode(result.getResponseCode());
        response.setRemark(result.getResponseRemark());
        return response;
    }

删除PrepareMessage，表示消息处理过了

/** * 删除PrepareMessage，其实是将原预处理消息存入一个新的主题RMQ_SYS_TRANS_OP_HALF_TOPIC， * 代表该消息已被处理 */
    @Override
    public boolean deletePrepareMessage(MessageExt msgExt) { 
        if (this.transactionalMessageBridge.putOpMessage(msgExt, TransactionalMessageUtil.REMOVETAG)) { 
            log.debug("Transaction op message write successfully. messageId={}, queueId={} msgExt:{}", msgExt.getMsgId(), msgExt.getQueueId(), msgExt);
            return true;
        } else { 
            log.error("Transaction op message write failed. messageId is {}, queueId is {}", msgExt.getMsgId(), msgExt.getQueueId());
            return false;
        }
    }

## 回查事务状态 ##

如果执行完本地事务返回本地事务状态为UN\_KNOW时，结束事务时将不做任何处理，或者在发送提交或回滚时失败，此时就需要通过事务回查机制定时的去应用程序检查本地的事务状态来决定是否提交或回滚。  
MQ通过TransactionalMessageCheckService线程服务定时去检测RMQ\_SYS\_TRANS\_HALF\_TOPIC主题中的消息，回查消息的事务状态。

@Override
    public void run() { 
        log.info("Start transaction check service thread!");
        // 检测间隔，默认60s
        long checkInterval = brokerController.getBrokerConfig().getTransactionCheckInterval();
        while (!this.isStopped()) { 
            // 最终调用onWaitEnd方法
            this.waitForRunning(checkInterval);
        }
        log.info("End transaction check service thread!");
    }
    
    @Override
    protected void onWaitEnd() { 
        // 表示事务的过期时间，一个消息的存储时间 + 该值 大于系统当前时间，才对该消息执行事务状态回查
        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**

@Override
    public void check(long transactionTimeout, int transactionCheckMax,
        AbstractTransactionalMessageCheckListener listener) { 
        try { 
            String topic = MixAll.RMQ_SYS_TRANS_HALF_TOPIC;
            // 获取事务消息topic下的所有消息队列
            Set<MessageQueue> msgQueues = transactionalMessageBridge.fetchMessageQueues(topic);
            if (msgQueues == null || msgQueues.size() == 0) { 
                log.warn("The queue of topic is empty :" + topic);
                return;
            }
            log.debug("Check topic={}, queues={}", topic, msgQueues);
            // 遍历所有消息队列
            for (MessageQueue messageQueue : msgQueues) { 
                long startTime = System.currentTimeMillis();
                // 根据messageQueue从缓存获取操作队列，如果没有，则创建一个，topic为RMQ_SYS_TRANS_OP_HALF_TOPIC，
                // queueId与messageQueue的queueId一样
                MessageQueue opQueue = getOpQueue(messageQueue);
                // 获取两个队列的offset
                long halfOffset = transactionalMessageBridge.fetchConsumeOffset(messageQueue);
                long opOffset = transactionalMessageBridge.fetchConsumeOffset(opQueue);
                log.info("Before check, the queue={} msgOffset={} opOffset={}", messageQueue, halfOffset, opOffset);
                if (halfOffset < 0 || opOffset < 0) { 
                    log.error("MessageQueue: {} illegal offset read: {}, op offset: {},skip this queue", messageQueue,
                        halfOffset, opOffset);
                    continue;
                }
    
                List<Long> doneOpOffset = new ArrayList<>();
                HashMap<Long, Long> removeMap = new HashMap<>();
                PullResult pullResult = fillOpRemoveMap(removeMap, opQueue, opOffset, halfOffset, doneOpOffset);
                if (null == pullResult) { 
                    log.error("The queue={} check msgOffset={} with opOffset={} failed, pullResult is null",
                        messageQueue, halfOffset, opOffset);
                    continue;
                }
                // single thread
                int getMessageNullCount = 1;
                long newOffset = halfOffset;
                long i = halfOffset;
                while (true) { 
                    if (System.currentTimeMillis() - startTime > MAX_PROCESS_TIME_LIMIT) { 
                        log.info("Queue={} process time reach max={}", messageQueue, MAX_PROCESS_TIME_LIMIT);
                        break;
                    }
                    if (removeMap.containsKey(i)) { 
                        log.info("Half offset {} has been committed/rolled back", i);
                        Long removedOpOffset = removeMap.remove(i);
                        doneOpOffset.add(removedOpOffset);
                    } else { 
                        GetResult getResult = getHalfMsg(messageQueue, i);
                        MessageExt msgExt = getResult.getMsg();
                        if (msgExt == null) { 
                            if (getMessageNullCount++ > MAX_RETRY_COUNT_WHEN_HALF_NULL) { 
                                break;
                            }
                            if (getResult.getPullResult().getPullStatus() == PullStatus.NO_NEW_MSG) { 
                                log.debug("No new msg, the miss offset={} in={}, continue check={}, pull result={}", i,
                                    messageQueue, getMessageNullCount, getResult.getPullResult());
                                break;
                            } else { 
                                log.info("Illegal offset, the miss offset={} in={}, continue check={}, pull result={}",
                                    i, messageQueue, getMessageNullCount, getResult.getPullResult());
                                i = getResult.getPullResult().getNextBeginOffset();
                                newOffset = i;
                                continue;
                            }
                        }
    
                        if (needDiscard(msgExt, transactionCheckMax) || needSkip(msgExt)) { 
                            listener.resolveDiscardMsg(msgExt);
                            newOffset = i + 1;
                            i++;
                            continue;
                        }
                        if (msgExt.getStoreTimestamp() >= startTime) { 
                            log.debug("Fresh stored. the miss offset={}, check it later, store={}", i,
                                new Date(msgExt.getStoreTimestamp()));
                            break;
                        }
    
                        long valueOfCurrentMinusBorn = System.currentTimeMillis() - msgExt.getBornTimestamp();
                        long checkImmunityTime = transactionTimeout;
                        String checkImmunityTimeStr = msgExt.getUserProperty(MessageConst.PROPERTY_CHECK_IMMUNITY_TIME_IN_SECONDS);
                        if (null != checkImmunityTimeStr) { 
                            checkImmunityTime = getImmunityTime(checkImmunityTimeStr, transactionTimeout);
                            if (valueOfCurrentMinusBorn < checkImmunityTime) { 
                                if (checkPrepareQueueOffset(removeMap, doneOpOffset, msgExt)) { 
                                    newOffset = i + 1;
                                    i++;
                                    continue;
                                }
                            }
                        } else { 
                            if ((0 <= valueOfCurrentMinusBorn) && (valueOfCurrentMinusBorn < checkImmunityTime)) { 
                                log.debug("New arrived, the miss offset={}, check it later checkImmunity={}, born={}", i,
                                    checkImmunityTime, new Date(msgExt.getBornTimestamp()));
                                break;
                            }
                        }
                        List<MessageExt> opMsg = pullResult.getMsgFoundList();
                        boolean isNeedCheck = (opMsg == null && valueOfCurrentMinusBorn > checkImmunityTime)
                            || (opMsg != null && (opMsg.get(opMsg.size() - 1).getBornTimestamp() - startTime > transactionTimeout))
                            || (valueOfCurrentMinusBorn <= -1);
    
                        if (isNeedCheck) { 
                            if (!putBackHalfMsgQueue(msgExt, i)) { 
                                continue;
                            }
                            // 消息回查
                            listener.resolveHalfMsg(msgExt);
                        } else { 
                            pullResult = fillOpRemoveMap(removeMap, opQueue, pullResult.getNextBeginOffset(), halfOffset, doneOpOffset);
                            log.debug("The miss offset:{} in messageQueue:{} need to get more opMsg, result is:{}", i,
                                messageQueue, pullResult);
                            continue;
                        }
                    }
                    newOffset = i + 1;
                    i++;
                }
                if (newOffset != halfOffset) { 
                    transactionalMessageBridge.updateConsumeOffset(messageQueue, newOffset);
                }
                long newOpOffset = calculateOpOffset(doneOpOffset, opOffset);
                if (newOpOffset != opOffset) { 
                    transactionalMessageBridge.updateConsumeOffset(opQueue, newOpOffset);
                }
            }
        } catch (Exception e) { 
            e.printStackTrace();
            log.error("Check error", e);
        }
    
    }

**AbstractTransactionalMessageCheckListener**

public void resolveHalfMsg(final MessageExt msgExt) { 
        executorService.execute(new Runnable() { 
            @Override
            public void run() { 
                try { 
                    sendCheckMessage(msgExt);
                } catch (Exception e) { 
                    LOGGER.error("Send check message error!", e);
                }
            }
        });
    }
    
    public void sendCheckMessage(MessageExt msgExt) throws Exception { 
        CheckTransactionStateRequestHeader checkTransactionStateRequestHeader = new CheckTransactionStateRequestHeader();
        checkTransactionStateRequestHeader.setCommitLogOffset(msgExt.getCommitLogOffset());
        checkTransactionStateRequestHeader.setOffsetMsgId(msgExt.getMsgId());
        checkTransactionStateRequestHeader.setMsgId(msgExt.getUserProperty(MessageConst.PROPERTY_UNIQ_CLIENT_MESSAGE_ID_KEYIDX));
        checkTransactionStateRequestHeader.setTransactionId(checkTransactionStateRequestHeader.getMsgId());
        checkTransactionStateRequestHeader.setTranStateTableOffset(msgExt.getQueueOffset());
        msgExt.setTopic(msgExt.getUserProperty(MessageConst.PROPERTY_REAL_TOPIC));
        msgExt.setQueueId(Integer.parseInt(msgExt.getUserProperty(MessageConst.PROPERTY_REAL_QUEUE_ID)));
        msgExt.setStoreSize(0);
        String groupId = msgExt.getProperty(MessageConst.PROPERTY_PRODUCER_GROUP);
        Channel channel = brokerController.getProducerManager().getAvaliableChannel(groupId);
        if (channel != null) { 
            // 发送回查请求
            brokerController.getBroker2Client().checkProducerTransactionState(groupId, channel, checkTransactionStateRequestHeader, msgExt);
        } else { 
            LOGGER.warn("Check transaction failed, channel is null. groupId={}", groupId);
        }
    }

生产端使用ClientRemotingProcessor处理请求

public RemotingCommand checkTransactionState(ChannelHandlerContext ctx,
        RemotingCommand request) throws RemotingCommandException { 
        final CheckTransactionStateRequestHeader requestHeader =
            (CheckTransactionStateRequestHeader) request.decodeCommandCustomHeader(CheckTransactionStateRequestHeader.class);
        final ByteBuffer byteBuffer = ByteBuffer.wrap(request.getBody());
        final MessageExt messageExt = MessageDecoder.decode(byteBuffer);
        if (messageExt != null) { 
            if (StringUtils.isNotEmpty(this.mqClientFactory.getClientConfig().getNamespace())) { 
                messageExt.setTopic(NamespaceUtil
                    .withoutNamespace(messageExt.getTopic(), this.mqClientFactory.getClientConfig().getNamespace()));
            }
            String transactionId = messageExt.getProperty(MessageConst.PROPERTY_UNIQ_CLIENT_MESSAGE_ID_KEYIDX);
            if (null != transactionId && !"".equals(transactionId)) { 
                messageExt.setTransactionId(transactionId);
            }
            final String group = messageExt.getProperty(MessageConst.PROPERTY_PRODUCER_GROUP);
            if (group != null) { 
                MQProducerInner producer = this.mqClientFactory.selectProducer(group);
                if (producer != null) { 
                    final String addr = RemotingHelper.parseChannelRemoteAddr(ctx.channel());
                    // 检查本地事务状态
                    producer.checkTransactionState(addr, messageExt, requestHeader);
                } else { 
                    log.debug("checkTransactionState, pick producer by group[{}] failed", group);
                }
            } else { 
                log.warn("checkTransactionState, pick producer group failed");
            }
        } else { 
            log.warn("checkTransactionState, decode message failed");
        }
    
        return null;
    }

**DefaultMQProducerImpl**

@Override
    public void checkTransactionState(final String addr, final MessageExt msg,
        final CheckTransactionStateRequestHeader header) { 
        Runnable request = new Runnable() { 
            private final String brokerAddr = addr;
            private final MessageExt message = msg;
            private final CheckTransactionStateRequestHeader checkRequestHeader = header;
            private final String group = DefaultMQProducerImpl.this.defaultMQProducer.getProducerGroup();
    
            @Override
            public void run() { 
                TransactionCheckListener transactionCheckListener = DefaultMQProducerImpl.this.checkListener();
                TransactionListener transactionListener = getCheckListener();
                if (transactionCheckListener != null || transactionListener != null) { 
                    LocalTransactionState localTransactionState = LocalTransactionState.UNKNOW;
                    Throwable exception = null;
                    try { 
                        if (transactionCheckListener != null) { 
                            localTransactionState = transactionCheckListener.checkLocalTransactionState(message);
                        } else if (transactionListener != null) { 
                            log.debug("Used new check API in transaction message");
                            // 回查本地事务状态
                            localTransactionState = transactionListener.checkLocalTransaction(message);
                        } else { 
                            log.warn("CheckTransactionState, pick transactionListener by group[{}] failed", group);
                        }
                    } catch (Throwable e) { 
                        log.error("Broker call checkTransactionState, but checkLocalTransactionState exception", e);
                        exception = e;
                    }
    
                    this.processTransactionState(
                        localTransactionState,
                        group,
                        exception);
                } else { 
                    log.warn("CheckTransactionState, pick transactionCheckListener by group[{}] failed", group);
                }
            }
    
            private void processTransactionState(
                final LocalTransactionState localTransactionState,
                final String producerGroup,
                final Throwable exception) { 
                final EndTransactionRequestHeader thisHeader = new EndTransactionRequestHeader();
                thisHeader.setCommitLogOffset(checkRequestHeader.getCommitLogOffset());
                thisHeader.setProducerGroup(producerGroup);
                thisHeader.setTranStateTableOffset(checkRequestHeader.getTranStateTableOffset());
                thisHeader.setFromTransactionCheck(true);
    
                String uniqueKey = message.getProperties().get(MessageConst.PROPERTY_UNIQ_CLIENT_MESSAGE_ID_KEYIDX);
                if (uniqueKey == null) { 
                    uniqueKey = message.getMsgId();
                }
                thisHeader.setMsgId(uniqueKey);
                thisHeader.setTransactionId(checkRequestHeader.getTransactionId());
                switch (localTransactionState) { 
                    case COMMIT_MESSAGE:
                        thisHeader.setCommitOrRollback(MessageSysFlag.TRANSACTION_COMMIT_TYPE);
                        break;
                    case ROLLBACK_MESSAGE:
                        thisHeader.setCommitOrRollback(MessageSysFlag.TRANSACTION_ROLLBACK_TYPE);
                        log.warn("when broker check, client rollback this transaction, {}", thisHeader);
                        break;
                    case UNKNOW:
                        thisHeader.setCommitOrRollback(MessageSysFlag.TRANSACTION_NOT_TYPE);
                        log.warn("when broker check, client does not know this transaction state, {}", thisHeader);
                        break;
                    default:
                        break;
                }
    
                String remark = null;
                if (exception != null) { 
                    remark = "checkLocalTransactionState Exception: " + RemotingHelper.exceptionSimpleDesc(exception);
                }
    
                try { 
                    // 根据回查本地事务的状态提交或回滚消息，单向请求
                    DefaultMQProducerImpl.this.mQClientFactory.getMQClientAPIImpl().endTransactionOneway(brokerAddr, thisHeader, remark,
                        3000);
                } catch (Exception e) { 
                    log.error("endTransactionOneway exception", e);
                }
            }
        };
    
        // 将回查任务提交给线程池执行
        this.checkExecutor.submit(request);
    }

通过调用自定义的监听器回查方法，检测本地事务状态，再根据回查本地事务的状态提交或回滚消息，单向请求。  
![在这里插入图片描述][406d9df6904c9b3d06fdc140cb389baa.png_pic_center]

## 参考资料 ##

《儒猿技术窝——从 0 开始带你成为消息中间件实战高手》

[b36990483ff31863bc915439a8ab868b.png_pic_center]: /images/20220828/3b1b3f945eda4357a65c2e72205b0601.png
[406d9df6904c9b3d06fdc140cb389baa.png_pic_center]: /images/20220828/95e015e4d595433bb6443fe8729a7f57.png