RocketMQ事务消息篇（三）之事务消息源码分析

事务消息处理基本流程

在介绍事务消息的时候，画了一个简单的流程图说明事务消息的整体处理流程：

p.s. 下面的序号(1、2、3...)表示顺序，与上图中的(1、2、3...)无关。

1. 事务生产者调用事务消息发送接口，发送消息
2. 开始预提交阶段，客户端发送预消息并在请求头标记这是一条事务消息。消息体就是我们实际要发送的消息内容
3. broker接收到消息，发现这是一条事务消息，于是将当前消息备份。所谓“备份”即将当前消息的所有数据写入内部的事务topic中而不是我们实际要发送的topic，该事务topic由于消费端并没有订阅，所以这条消息对消费端不可见，然后响应客户端的发送请求
4. 客户端确认发送成功，则执行本地事务，并标记事务执行状态。如果发送失败，就不需要执行本地事务了，直接标记事务执行失败，需要回滚。
5. 基于事务的执行状态，给本次发送事务消息的那个broker发送一条结束事务的请求（请求头里包含是提交还是回滚，亦或者是未知状态）
6. broker收到事务结束的请求，如果是未知状态就打条日志直接返回了；如果是提交事务，就将备份的那条事务消息恢复过来，写入到原始的topic里，此时就对消费端可见了，然后要在op队列里（另一个内部topic）写入一条消息，消息体就是当前这条事务消息的队列偏移值。如果是回滚事务，就只用在op队列里写入一条消息即可，就不还原事务消息了，这样对消费端就不可见。关于op队列的具体作用，后面源码部分再详说。
7. 说一下事务回查。事务回查就是broker扫描到那些没有提交也没回滚的消息，找到客户端，发一个请求，让客户端再次提交一下事务结束状态。

源码剖析

整体流程涉及的代码还是比较多的，接下来对每一部分的源码拆开进行分析。

客户端处理，事务执行流程

客户端处理基本流程如下：

源码的主要入口实现部分在这个方法里： org.apache.rocketmq.client.impl.producer.DefaultMQProducerImpl#sendMessageInTransaction(final Message msg, final LocalTransactionExecuter localTransactionExecuter, final Object arg) throws MQClientException;

代码如下，我已经加上相关注释：

    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);
        }
 
        // 事务消息不支持延时消息
        // ignore DelayTimeLevel parameter
        if (msg.getDelayTimeLevel() != 0) {
            MessageAccessor.clearProperty(msg, MessageConst.PROPERTY_DELAY_TIME_LEVEL);
        }
 
        Validators.checkMessage(msg, this.defaultMQProducer);
 
        SendResult sendResult = null;
        // 设置半消息属性（TRAN_MSG），标志这是一个事务半消息
        MessageAccessor.putProperty(msg, MessageConst.PROPERTY_TRANSACTION_PREPARED, "true");
        // 设置生产组属性（PGROUP）
        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 {
                    // transactionId
                    if (sendResult.getTransactionId() != null) {
                        msg.putUserProperty("__transactionId__", sendResult.getTransactionId());
                    }
                    // UNIQ_KEY,这是客户端发送的时侯生成的一个唯一ID，也就是我们平常用的sendResult里的msgId
                    String transactionId = msg.getProperty(MessageConst.PROPERTY_UNIQ_CLIENT_MESSAGE_ID_KEYIDX);
                    if (null != transactionId && !"".equals(transactionId)) {
                        // 在这种情况下，transactionId其实就是message的客户端msgId
                        msg.setTransactionId(transactionId);
                    }
                    // 一般，我平常使用的时候，不会采用localTransactionExecuter方式调用事务消息接口，所以这里一般是空
                    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;
            // 未发送成功，回滚消息
            case FLUSH_DISK_TIMEOUT:
            case FLUSH_SLAVE_TIMEOUT:
            case SLAVE_NOT_AVAILABLE:
                localTransactionState = LocalTransactionState.ROLLBACK_MESSAGE;
                break;
            default:
                break;
        }
 
        try {
            // 事务结束处理，是提交还是回滚还是要做其它操作
            this.endTransaction(msg, 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;
    }
复制代码

关于上面调用事务结束请求的方法，具体代码及注释如下：

    public void endTransaction(
        final Message msg,
        final SendResult sendResult,
        final LocalTransactionState localTransactionState,
        final Throwable localException) throws RemotingException, MQBrokerException, InterruptedException, UnknownHostException {
        final MessageId id;
        // getOffsetMsgId，这个是服务端的msgId，包含了不少消息的元信息
        if (sendResult.getOffsetMsgId() != null) {
            id = MessageDecoder.decodeMessageId(sendResult.getOffsetMsgId());
        } else {
            id = MessageDecoder.decodeMessageId(sendResult.getMsgId());
        }
        String transactionId = sendResult.getTransactionId();
        // 半消息发到了哪个broker上，最后提交也得到这个broker上
        final String broker