秒杀系统 | 交易性能优化 | 库存缓存化（三）RocketMQ 事务型消息让 MySQL 同步 Redis 中的库存...

现存代码问题分析

• decreaseStock 方法被 @Transactional 标注，并且调用 decreaseStock 的方法 createOrder 也被 @Transactional 标注，根据 Spring 的事务传播机制，默认 decreaseStock 会沿用 createOrder 的事务，也就是说和 createOrder 的事务同时成功或同时失败；
• 原先 decreaseStock 代码是 MySQL 操作，意味着，如果 decreaseStock 之后的大事务中的代码报错，decreaseStock 中对 MySQL 的更改是可以回滚的；但是现在改用 Redis 和 MQ 之后，如果之后的大事务失败（比如订单入库失败、销量增加失败），对 Redis 的更改以及对 MQ 发出的消息和造成的 MySQL 的更改是无法恢复的，返回给用户的下单失败，但是库存就损失掉了，虽然不会造成超卖，但是会造成少卖，库存莫名其妙的少了，但是又找不到对应的订单，导致货物积压；
• 问题的本质其实是分布式事务的问题，RocketMQ 是提供了事务型消息的支持的；

@Override
@Transactional
public boolean decreaseStock(Integer itemId, Integer amount) {
//        int affectedRows = itemStockDOMapper.decreaseStock(itemId, amount);
    long result = redisTemplate.opsForValue().increment("promo_item_stock_" + itemId, amount * -1);
    if (result >= 0) {
        boolean mqResult = mqProducer.asyncReduceStock(itemId, amount);
        if (!mqResult) {
            redisTemplate.opsForValue().increment("promo_item_stock_" + itemId, amount);
            return false;
        }
        return true;
    } else {
        redisTemplate.opsForValue().increment("promo_item_stock_" + itemId, amount);
        return false;
    }
}

小知识：Spring 提供le在事务 Commit 成功之后再做点事情的能力

• 如果 afterCommit 方法执行失败，那么事务中已经提交成功的数据是不能回滚的；

@Transactional
public void createOrder() {

  // some operation in transaction

  TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
      // 这个方法会在最近的一个 @Transactional 标签被成功 Commit 之后执行
      @Override
      public void afterCommit() {
          super.afterCommit();
      }
  });
}

RocketMQ 的事务型消息

在 Producer 的封装中，增加发送事务型消息的方法

• 事务型消息的发送逻辑为：
  1. 先发送 Prepared 状态的消息到 Broker 中；
  2. 再执行本地事务（下单），本地事务的执行在回调方法 executeLocalTransaction 中；
  3. 根据本地事务（下单）的成功与否决定提交 Broker 中的消息还是撤回；

package com.lixinlei.miaosha.mq;

import com.alibaba.fastjson.JSON;
import com.lixinlei.miaosha.error.BusinessException;
import com.lixinlei.miaosha.service.OrderService;
import com.lixinlei.miaosha.service.model.OrderModel;
import org.apache.rocketmq.client.exception.MQBrokerException;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.client.producer.*;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.remoting.exception.RemotingException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.nio.charset.Charset;
import java.util.HashMap;
import java.util.Map;

@Component
public class MqProducer {

    private DefaultMQProducer producer;

    private TransactionMQProducer transactionMQProducer;

    @Value("${mq.nameserver.addr}")
    private String nameAddr;

    @Value("${mq.topicname}")
    private String topicName;

    @Autowired
    private OrderService orderService;

    /**
     * 在 Bean 初始化完成之后调用
     */
    @PostConstruct
    public void init() throws MQClientException {
        producer = new DefaultMQProducer("producer_group");
        producer.setNamesrvAddr(nameAddr);
        producer.start();

        transactionMQProducer = new TransactionMQProducer("transaction_producer_group");
        transactionMQProducer.setNamesrvAddr(nameAddr);
        transactionMQProducer.start();
        transactionMQProducer.setTransactionListener(new TransactionListener() {
            /**
             * 消息以 Prepared 状态被保存进 Broker 后执行
             * @param message
             * @param args `transactionMQProducer.sendMessageInTransaction(message, argsMap)` 中传入的 `argsMap`
             * @return
             */
            @Override
            public LocalTransactionState executeLocalTransaction(Message message, Object args) {
                // 真正要执行的操作：创建订单
                Integer userId = (Integer)((Map) args).get("userId");
                Integer itemId = (Integer)((Map) args).get("itemId");
                Integer promoId = (Integer)((Map) args).get("promoId");
                Integer amount = (Integer)((Map) args).get("amount");
                try {
                    OrderModel orderModel = orderService.createOrder(userId, itemId, promoId, amount);
                } catch (BusinessException e) {
                    e.printStackTrace();
                    return LocalTransactionState.ROLLBACK_MESSAGE;
                }
                return LocalTransactionState.COMMIT_MESSAGE;
            }

            /**
             * 如果 `OrderModel orderModel = orderService.createOrder(userId, itemId, promoId, amount)` 执行成功了，但是
             * Tomcat 和 MySQL 中的连接断了，既走不到 ROLLBACK_MESSAGE，也走不到 COMMIT_MESSAGE，那么这个事务型消息的状态就是
             * UNKNOW，在 UNKNOW 的情况下，Broker 会定期回调本方法；
             * @param msg
             * @return
             */
            @Override
            public LocalTransactionState checkLocalTransaction(MessageExt msg) {
                return null;
            }
        });
    }

    /**
     * 事务型让 MySQL 同步 Redis 中库存扣减的消息
     * @param itemId
     * @param amount
     * @return
     */
    public boolean transactionAsyncReduceStock(Integer userId, Integer promoId, Integer itemId, Integer amount) {
        Map<String, Object> bodyMap = new HashMap<>();
        bodyMap.put("itemId", itemId);
        bodyMap.put("amount", amount);

        Map<String, Object> argsMap = new HashMap<>();
        argsMap.put("itemId", itemId);
        argsMap.put("amount", amount);
        argsMap.put("userId", userId);
        argsMap.put("promoId", promoId);

        Message message = new Message(
                topicName,
                "increase",
                JSON.toJSON(bodyMap).toString().getBytes(Charset.forName("UTF-8")));
        TransactionSendResult sendResult = null;
        try {
            /**
             * 事务型消息有一个二阶段提交的概念：
             * 消息发出后，Broker 的确可以收到消息，但是状态是不可被消费的状态，而是 Prepared 状态;
             * 消息发出后，会回调 Producer 端的 executeLocalTransaction 方法;
             */
            sendResult = transactionMQProducer.sendMessageInTransaction(message, argsMap);
        } catch (MQClientException e) {
            e.printStackTrace();
            return false;
        }
        if (sendResult.getLocalTransactionState() == LocalTransactionState.ROLLBACK_MESSAGE) {
            return false;
        } else if (sendResult.getLocalTransactionState() == LocalTransactionState.COMMIT_MESSAGE) {
            return true;
        } else {
            return false;
        }
    }

}

不再是 Controller 直接调用下单的 Service

• Controller 直接发送事务型消息给 Broker，下单操作作为本地事务在回调中执行；

@RequestMapping(value = "/createorder", method = {RequestMethod.POST}, consumes = {CONTENT_TYPE_FORMED})
@ResponseBody
public CommonReturnType createOrder(@RequestParam(name = "itemId") Integer itemId,
                                    @RequestParam(name = "amount") Integer amount,
                                    @RequestParam(name = "promoId", required = false) Integer promoId) throws BusinessException {
    String token = httpServletRequest.getParameterMap().get("token")[0];
    if (StringUtils.isEmpty(token)) {
        throw new BusinessException(EmBusinessError.USER_NOT_LOGIN, "用户还未登录，不能下单");
    }
    UserModel userModel = (UserModel) redisTemplate.opsForValue().get(token);
    if (userModel == null) {
        throw new BusinessException(EmBusinessError.USER_NOT_LOGIN, "用户还未登录，不能下单");
    }
//        OrderModel orderModel = orderService.createOrder(userModel.getId(), itemId, promoId, amount);
    if(!mqProducer.transactionAsyncReduceStock(userModel.getId(), promoId, itemId, amount)) {
        throw new BusinessException(EmBusinessError.UNKNOWN_ERROR, "下单失败");
    }
    return CommonReturnType.create(null);
}

减库存的操作中不再给 MQ 发消息

• 给 Broker 发扣减库存的消息不再跟在 Redis 操作（减 Redis 中的库存）之后，而是作为事务型消息，由 Controller 发送；

@Override
@Transactional
public boolean decreaseStock(Integer itemId, Integer amount) {
//        int affectedRows = itemStockDOMapper.decreaseStock(itemId, amount);
    long result = redisTemplate.opsForValue().increment("promo_item_stock_" + itemId, amount * -1);
    if (result >= 0) {
//            boolean mqResult = mqProducer.asyncReduceStock(itemId, amount);
//            if (!mqResult) {
//                redisTemplate.opsForValue().increment("promo_item_stock_" + itemId, amount);
//                return false;
//            }
        return true;
    } else {
        redisTemplate.opsForValue().increment("promo_item_stock_" + itemId, amount);
        return false;
    }
}