现存代码问题分析
-
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;
}
}
