RocketMq分布式事务

先抛出问题
老生常谈的问题：就是A，B在不同的服务器，然后A账户减钱，B账户加钱。因为他们不在同一个事务下，所以，就会出现A减钱，B加钱没成，然后就导致数据不完整。

那么RocketMq是如何解决这问题呢
采用：最终一致性
RocketMq消息中间件把消息分为两个阶段：Prepared阶段和确认阶段Prepared阶段（预备阶段）

• Prepared阶段（预备阶段）
  该阶段主要发一个消息到rocketmq，但该消息只储存在commitlog中，但consumeQueue中不可见，也就是消费端（订阅端）无法看到此消息。
• commit/rollback阶段（确认阶段）
  该阶段主要是把prepared消息保存到consumeQueue中，即让消费端可以看到此消息，也就是可以消费此消息。

核心思路就是【状态回查】，也就是RocketMq会定时遍历commitlog中的预备消息。
因为预备消息最终肯定会变为commit消息或Rollback消息，所以遍历预备消息去回查本地业务的执行状态，如果发现本地业务没有执行成功就rollBack，如果执行成功就发送commit消息。

OK，很好理解吧，我们开始上代码，接着我们之前的demo改造，demo地址：spirngboot集成rocketmq

这里我们先改造DefaultProductConfig类

@Component
public class DefaultProductConfig {

    @Value("${rocketmq.producer.group}")
    private String producerGroup;
    @Value("${rocketmq.name-server}")
    private String nameServer;
	//我们用带事务的生产者，并且，这里把生产者的事务监听器注册进来ProducerTxmsgListener
    @Bean
    public TransactionMQProducer getProduct() throws MQClientException {
        //带事务的生产者
        TransactionMQProducer producer = new TransactionMQProducer(producerGroup);
        producer.setVipChannelEnabled(false);
        //绑定name server
        producer.setNamesrvAddr(nameServer);
        producer.setTransactionListener(new ProducerTxmsgListener());
        return producer;
    }
}

事务监听器：ProducerTxmsgListener

@Component
public class ProducerTxmsgListener implements TransactionListener {

    final static Logger logger = LoggerFactory.getLogger(ProducerTxmsgListener.class);
	//这个是执行事务的过程，看return返回的是状态，是提交，还是未知，还是直接回滚
    @Override
    public LocalTransactionState executeLocalTransaction(Message msg, Object arg) {
        try {
            String jsonString = new String(msg.getBody());
            logger.info("执行本地事务：发送的消息为{}", jsonString);
            return LocalTransactionState.UNKNOW;
        } catch (Exception e) {
            logger.error("executeLocalTransaction 事务执行失败", e);
            e.printStackTrace();
            return LocalTransactionState.ROLLBACK_MESSAGE;
        }
    }
	//这里是如果上面方法返回的是未知，就开始执行这个方法，做本地检查，并最终判断这个提交消息，是需要发送成功，还是回滚
    @Override
    public LocalTransactionState checkLocalTransaction(MessageExt msg) {
        LocalTransactionState state;
        String jsonString = new String(msg.getBody());
        logger.info("检查本地事务：发送的消息为{}", jsonString);
        if (jsonString != null) {
            state = LocalTransactionState.COMMIT_MESSAGE;
        } else {
            state = LocalTransactionState.ROLLBACK_MESSAGE;
        }
        return state;
    }

然后是发送消息工具类：SendMsgUtil

@Component
public class SendMsgUtil {

    final static Logger logger = LoggerFactory.getLogger(SendMsgUtil.class);

    @Value("${rocketmq.topic-key}")
    private String topic;

    @Autowired
    TransactionMQProducer defaultMQProducer;

    public SendResult sendMsg(Order order, MsgProductBean object) {
        Message message = new Message(topic, object.getTagName(), (order.getOrderNo() + " : " + order.getOrderStatus()).getBytes());
        try {
//            SendResult sendResult = defaultMQProducer.send(message);

//            SendResult sendResult = defaultMQProducer.send(message, new SelectMessageQueueByHash(), order.getOrderNo());

//            logger.info("Product：发送状态={}, 存储queue={}, 订单order={} , 订单状态status={}", sendResult.getSendStatus(),
//                    sendResult.getMessageQueue().getQueueId(), order.getOrderNo(), order.getOrderStatus());
			//这里返回的状态不代表消息是否发送成功
            TransactionSendResult sendResult = defaultMQProducer.sendMessageInTransaction(message, null);

            logger.info("返回状态：" + sendResult.getSendStatus());

            return null;
        } catch (MQClientException e) {
            e.printStackTrace();
        }
        return null;
    }

消费端代码不变，我们进行测试，我们预提交，先返回未知状态，然后在回查事务的时候，返回状态是提交，然后看消费端消费消息的时机

发送消息端：

可以看到消费端没有收到任务结果：

当我们回查事务成功时：
生产端：
消费端：

那B服务失败怎么办？

如果B最终执行失败，几乎可以断定就是代码有问题所以才引起的异常，因为消费端RocketMQ有重试机制，如果不是代码问题一般重试几次就能成功。如果是代码的原因引起多次重试失败后，也没有关系，将该异常记录下来，由人工处理，人工兜底处理后，就可以让事务达到最终的一致性。