rocketmq整合mysql事务_秒杀系统 | 交易性能优化 | 库存缓存化（三）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 的封装中，增加发送事务型消息的方法

事务型消息的发送逻辑为：

先发送 Prepared 状态的消息到 Broker 中；

再执行本地事务(下单)，本地事务的执行在回调方法 executeLocalTransaction 中；

根据本地事务(下单)的成功与否决定提交 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 bodyMap = new HashMap<>();

bodyMap.put("itemId", itemId);

bodyMap.put("amount", amount);

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

}

}