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

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方法中，如下所示：

@Override

public void check(long transactionTimeout, int transactionCheckMax,

AbstractTransactionalMessageCheckListener listener) {

try {

String topic = MixAll.RMQ_SYS_TRANS_HALF_TOPIC;

//获取半消息下的所有messageQueue

Set 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);

//遍历messageQueue，从队列中获取具体的消息

for (MessageQueue messageQueue : msgQueues) {

//获取对应的操作队列，其主题为：RMQ_SYS_TRANS_OP_HALF_TOPIC，然后获取操作队列的消费进度、待操作的消费队列的消费进度，如果任意一小于0，忽略该消息队列，继续处理下一个队列

long startTime = System.currentTimeMillis();

MessageQueue opQueue = getOpQueue(messageQueue);

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 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);

removeMap.remove(i);

} 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 {