SpringBoot 2.X 整合 rocketmq-spring-boot-starter 2.2.0 实现事务消息

我的springboot的版本是2.1.3 rocketmq-spring-boot-starter版本是2.2.0

之前我的博文手把手带你 SpringBoot 2.X 整合 RocketMq 实现了rocketmq的异步消息生产消费和顺序消息生产和消费 今天来学习一下RocketMQ事务消息的发送消费。

RocketMQ的事务消息分为3种状态，分别是提交状态、回滚状态、中间状态：

TransactionStatus.CommitTransaction: 提交事务，它允许消费者消费此消息。
TransactionStatus.RollbackTransaction: 回滚事务，它代表该消息将被删除，不允许被消费。
TransactionStatus.Unknown: 中间状态，它代表需要检查消息队列来确定状态。

事务消息在解决分布式事务的场景中感觉还是很有用的，虽然我们现在项目的分布式事务是通过Seata来实现的，但是通过事务消息或者消息的最终一次性也是可以的。
事务消息总共分为3个阶段：发送Prepared消息、执行本地事务、发送确认消息。这三个阶段是前后关联的，只有发送Prepared消息成功，才会执行本地事务，本地事务返回的状态是提交，那么就会发送最终的确认消息。如果在结束消息事务时，本地事务状态失败，那么Broker回查线程定时（默认1分钟）扫描每个存储事务状态的表格文件，如果是已经提交或者回滚的消息直接跳过，如果是Prepared状态则会向生产者发起一个检查本地事务的请求。

一 代码实现

我对我之前的代码进行了修改，先大致看一下代码结构

增加了 数据库的连接，mapper，service等

数据库创建两个表

CREATE TABLE `order_entity` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `order_type` varchar(50) DEFAULT NULL COMMENT '订单类型',
  `order_no` varchar(50) DEFAULT NULL COMMENT '订单编号',
  `price` decimal(10,2) DEFAULT NULL COMMENT '订单总价',
  `user_id` int(11) DEFAULT NULL  COMMENT '下单用户id',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;


CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(50) DEFAULT NULL COMMENT '姓名',
  `age` int(10) DEFAULT NULL COMMENT '年龄',
  `account` decimal(10,2) DEFAULT NULL COMMENT '账户余额',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;

用户实体

package com.example.entity;

/**
 * @author guog
 * @create 2021-04-21 17:39
 */
public class User {
    String name;
    Integer id;
    Integer age;
    Double account;// 用户账户

    public Double getAccount() {
        return account;
    }

    public void setAccount(Double account) {
        this.account = account;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

UserMapper

@Mapper
public interface UserMapper extends BaseMapper<User> {

}

UserMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper
	namespace="com.example.mapper.UserMapper">
</mapper>

订单实体

package com.example.entity;


/**
 * @author guog
 * @create 2021-04-22 11:32
 */
public class OrderEntity {
    Integer id;
    Integer userId;//下单用户id
    String orderType;
    String orderNo;
    Double price;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getOrderType() {
        return orderType;
    }

    public void setOrderType(String orderType) {
        this.orderType = orderType;
    }

    public String getOrderNo() {
        return orderNo;
    }

    public void setOrderNo(String orderNo) {
        this.orderNo = orderNo;
    }

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }

    public Integer getUserId() {
        return userId;
    }

    public void setUserId(Integer userId) {
        this.userId = userId;
    }
}

订单mapper

@Mapper
public interface OrderMapper extends BaseMapper<OrderEntity> {

}

OrderMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper
	namespace="com.example.mapper.OrderMapper">

</mapper>

在之前的testController 中加一个增加订单的方法

    /**
     * 模拟事务消息
     *
     * 步骤一 创建订单
     * 功能：发送事务消息
     */
    @GetMapping("addOrder")
    public String addOrder() {
        OrderEntity order=new OrderEntity();
        order.setOrderNo("11111");
        order.setUserId(1);
        order.setPrice(200.00);
        TransactionSendResult sendResult= rocketMqHelper.transactionSend("TX_ORDER_ADD",MessageBuilder.withPayload(order).build(),order);
        String sendStatus = sendResult.getSendStatus().name();
        String localTXState = sendResult.getLocalTransactionState().name();
        System.out.println("sendStatus---"+sendStatus);
        System.out.println("localTXState---"+localTXState);
        return "success";
    }

rocketMqHelper 工具类增加发送事务消息方法 transactionSend

    /**
     * 发送事务消息
     *
     * @param topic
     * @param message
     * @param arg
     */
    public TransactionSendResult transactionSend(String topic, Message<?> message,Object arg) {
        LOG.info("发送事务消息，topic:" + topic );
        TransactionSendResult sendResult=rocketMQTemplate.sendMessageInTransaction(topic,message,arg);
        return sendResult;
    }

接下来我们创建一个消息的监听器（消费者），这个和普通消息的监听器一样我只是加了操作数据库的代码，代码如下：

/**
 * @author guog
 * @create 2021-04-21 17:40
 */
@Component
@RocketMQMessageListener(consumerGroup = "${rocketmq.producer.groupName1}", topic = "TX_ORDER_ADD",consumeMode = ConsumeMode.ORDERLY)
public class OrderMqListener implements RocketMQListener<OrderEntity> {


    @Autowired
    private UserMapper userMapper;
    
@Override
@Transactional
public void onMessage(OrderEntity order) {
                System.out.println("接收到消息，开始消费..OrderType:" + order.getOrderType() + ",OrderNO:" + order.getOrderNo());
                 // 一般真实环境这里消费前，得做幂等性判断，防止重复消费
    // 方法一：如果你的业务中有某个字段是唯一的，有标识性，如订单号，那就可以用此字段来判断
    // 方法二：新建一张消费记录表t_mq_consumer_log，字段consumer_key是唯一性，能插入则表明该消息还未消费，往下走，否则停止消费
    // 我个人建议用方法二，根据你的项目业务来定义key，这里我就不做幂等判断了，因为此案例只是模拟，重在分布式事务
                User user=userMapper.selectById(order.getUserId());
                user.setAccount(user.getAccount()-order.getPrice());
                userMapper.updateById(user);
        }
 }

除了消费者之外，我们还需要创建事务消息生产者端的消息监听器，注意是生产者，不是消费者，我们需要实现的是RocketMQLocalTransactionListener接口，代码如下：

/**
 * 订单事务消息生产监听
 * @author guog
 * @create 2021-04-21 17:40
 */
@Component
@RocketMQTransactionListener
public class OrderTXMsgListener  implements RocketMQLocalTransactionListener {

    /**
     * 日志
     */
    private static final Logger log = LoggerFactory.getLogger(OrderTXMsgListener.class);
    private static final Gson GSON = new Gson();

    @Autowired
    private OrderService orderService;

    /**
     * 步骤二：
     * 描述：mq收到事务消息后，开始执行本地事务
     * @Transactional：开启本地事务
     * @param msg
     * @param arg
     * @return
     */

    @Override
    public RocketMQLocalTransactionState executeLocalTransaction(Message msg, Object arg) {
        log.info(">>>> TX message listener execute local transaction, message={},args={} <<<<",msg,arg);
        // 执行本地事务
        RocketMQLocalTransactionState result = RocketMQLocalTransactionState.COMMIT;
        try {
            String jsonString = new String((byte[]) msg.getPayload(), StandardCharsets.UTF_8);
            OrderEntity order = GSON.fromJson(jsonString, OrderEntity.class);
            orderService.addOrder(order);
        } catch (Exception e) {
            log.error(">>>> exception message={} <<<<",e.getMessage());
            result = RocketMQLocalTransactionState.UNKNOWN;
        }
        return result;
    }

    /**
     * 步骤四
     * 描述：mq回调检查本地事务执行情况
     * @param msg
     * @return
     */

    @Override
    public RocketMQLocalTransactionState checkLocalTransaction(Message msg) {
        log.info(">>>> TX message listener check local transaction, message={} <<<<",msg.getPayload());
        // 检查本地事务
        RocketMQLocalTransactionState result = RocketMQLocalTransactionState.COMMIT;
        try {
            String jsonString = new String((byte[]) msg.getPayload(), StandardCharsets.UTF_8);
            OrderEntity order = GSON.fromJson(jsonString, OrderEntity.class);
            List<OrderEntity> list = orderService.selectOrder(order);
            if(list.size()<=0){
                result = RocketMQLocalTransactionState.UNKNOWN;
            }

        } catch (Exception e) {
            // 异常就回滚
            log.error(">>>> exception message={} <<<<",e.getMessage());
            result = RocketMQLocalTransactionState.ROLLBACK;
        }
        return result;
    }
}

写了个订单的OrderService

/**
 * @author guog
 * @create 2021-04-26 16:18
 */
@Service
public class OrderService {

    @Autowired
    private OrderMapper orderMapper;


    @Transactional
    public void addOrder(OrderEntity order) {
        orderMapper.insert(order);
    }

    public  List<OrderEntity> selectOrder(OrderEntity order) {
        QueryWrapper<OrderEntity> query=new QueryWrapper<>();
        query.in("order_no", order.getOrderNo());
        List<OrderEntity> list = orderMapper.selectList(query);
        return list;
    }
}

application.yml

server:
  port: 8088
#rocketmq配置
rocketmq:
  name-server: 127.0.0.1:9876
  # 生产者配置
  producer:
    isOnOff: on
    # 发送同一类消息的设置为同一个group，保证唯一
    group: user-rocketmq-group
    groupName: user-rocketmq-group

    group1: order-rocketmq-group
    groupName1: order-rocketmq-group
    # 服务地址
    namesrvAddr: 127.0.0.1:9876
    # 消息最大长度 默认1024*4(4M)
    maxMessageSize: 4096
    # 发送消息超时时间,默认3000
    sendMsgTimeout: 3000
    # 发送消息失败重试次数，默认2
    retryTimesWhenSendFailed: 2

spring:
  datasource:
    type: com.zaxxer.hikari.HikariDataSource
    url: jdbc:mysql://127.0.0.1:3306/rocket_deom?useUnicode=true&useSSL=false&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&serverTimezone=GMT%2b8
    username: root
    password: 123456
    hikari:
      connection-test-query: SELECT 1
      driver-class-name: com.mysql.cj.jdbc.Driver
      connection-timeout: 60000
      minimum-idle: 5
      maximum-pool-size: 15
      idle-timeout: 600000
      max-lifetime: 1200000
      auto-commit: true

mybatis-plus:
  mapper-locations:
    -    classpath*:com/example/mapper/*Mapper.xml
  type-aliases-package: com.sxmpx.entity
  global-config:
    db-config:
      db-type: mysql
      id-type: auto
      field-strategy: default
      capital-mode: true

二、消息事务测试

2.1 演示正常的流程

现在数据库加一个用户 并且用户的账户为500元

订单表为空

生成一个订单号为11111的订单 订单总价为200元 并且下单用户是上面创建的用户 user_id为1

首先还是正常的启动项目，访问addOrder方法，在执行本地事务方法中正常情况下返回的值是COMMIT，即提交事务，这种情况下消费者会直接消费消息，而略过检查本地事务的方法。调用该接口，项目日志输出如下：

通过日志分析可以看出，在执行完本地事务方法之后，返回的本地事务状态是COMMIT_MESSAGE，接着消费者消费消息，和我们的预期是一样的。

2021-04-27 14:06:59.198  INFO 8436 --- [nio-8088-exec-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring DispatcherServlet 'dispatcherServlet'
2021-04-27 14:06:59.198  INFO 8436 --- [nio-8088-exec-1] o.s.web.servlet.DispatcherServlet        : Initializing Servlet 'dispatcherServlet'
2021-04-27 14:06:59.203  INFO 8436 --- [nio-8088-exec-1] o.s.web.servlet.DispatcherServlet        : Completed initialization in 5 ms
2021-04-27 14:06:59.229  INFO 8436 --- [nio-8088-exec-1] com.example.utils.RocketMqHelper         : 发送事务消息，topic:TX_ORDER_ADD
2021-04-27 14:06:59.442  INFO 8436 --- [nio-8088-exec-1] com.example.Listener.OrderTXMsgListener  : >>>> TX message listener execute local transaction, message=GenericMessage [payload=byte[71], headers={rocketmq_TOPIC=TX_ORDER_ADD, rocketmq_FLAG=0, id=b896a47c-d3df-d955-bd36-d551d80bc400, contentType=application/json;charset=UTF-8, rocketmq_TRANSACTION_ID=7F00000120F418B4AAC288ECC9210000, timestamp=1619503619442}],args=com.example.entity.OrderEntity@3498d027 <<<<
2021-04-27 14:06:59.450  INFO 8436 --- [nio-8088-exec-1] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Starting...
2021-04-27 14:06:59.539  INFO 8436 --- [nio-8088-exec-1] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Start completed.
sendStatus---SEND_OK
localTXState---COMMIT_MESSAGE
接收到消息，开始消费..OrderType:null,OrderNO:11111

用户的余额变成了300元

订单表里加了一条

2.2 模仿本地事务执行失败

简单改造下执行本地事务的方法，让直接返回 RocketMQLocalTransactionState.UNKNOWN

    /**
     * 步骤二：
     * 描述：mq收到事务消息后，开始执行本地事务
     * @Transactional：开启本地事务
     * @param msg
     * @param arg
     * @return
     */

    @Override
    public RocketMQLocalTransactionState executeLocalTransaction(Message msg, Object arg) {
        log.info(">>>> TX message listener execute local transaction, message={},args={} <<<<",msg,arg);
        // 执行本地事务
        RocketMQLocalTransactionState result = RocketMQLocalTransactionState.COMMIT;
        try {
            String jsonString = new String((byte[]) msg.getPayload(), StandardCharsets.UTF_8);
            OrderEntity order = GSON.fromJson(jsonString, OrderEntity.class);
            orderService.addOrder(order);
        } catch (Exception e) {
            log.error(">>>> exception message={} <<<<",e.getMessage());
            result = RocketMQLocalTransactionState.UNKNOWN;
        }
        return RocketMQLocalTransactionState.UNKNOWN;//改造这里直接返回UNKNOWN
    }

这样因为发生异常，该方法返回的结果是UNKNOWN，根据上文的分析，执行本地事务方法之后应该会执行检查本地事务方法，如果查询到有这条订单的order_no的数据 返回COMMIT 消费者继续消费信息

/**
     * 步骤四
     * 描述：mq回调检查本地事务执行情况
     * @param msg
     * @return
     */

    @Override
    public RocketMQLocalTransactionState checkLocalTransaction(Message msg) {
        log.info(">>>> TX message listener check local transaction, message={} <<<<",msg.getPayload());
        // 检查本地事务
        RocketMQLocalTransactionState result = RocketMQLocalTransactionState.COMMIT;
        try {
            String jsonString = new String((byte[]) msg.getPayload(), StandardCharsets.UTF_8);
            OrderEntity order = GSON.fromJson(jsonString, OrderEntity.class);
            List<OrderEntity> list = orderService.selectOrder(order);
            if(list.size()<=0){
                result = RocketMQLocalTransactionState.UNKNOWN;
            }

        } catch (Exception e) {
            // 异常就回滚
            log.error(">>>> exception message={} <<<<",e.getMessage());
            result = RocketMQLocalTransactionState.ROLLBACK;
        }
        return result;
    }

清空订单表，重启项目之后，再次调用一下接口，查看日志输出如下：

2021-04-27 14:24:14.855  INFO 20668 --- [nio-8088-exec-1] com.example.utils.RocketMqHelper         : 发送事务消息，topic:TX_ORDER_ADD
2021-04-27 14:24:15.038  INFO 20668 --- [nio-8088-exec-1] com.example.Listener.OrderTXMsgListener  : >>>> TX message listener execute local transaction, message=GenericMessage [payload=byte[71], headers={rocketmq_TOPIC=TX_ORDER_ADD, rocketmq_FLAG=0, id=0c1dc077-ca38-08a1-b0f1-65444f3a8a42, contentType=application/json;charset=UTF-8, rocketmq_TRANSACTION_ID=7F00000150BC18B4AAC288FC96700000, timestamp=1619504655038}],args=com.example.entity.OrderEntity@47bc7591 <<<<
2021-04-27 14:24:15.047  INFO 20668 --- [nio-8088-exec-1] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Starting...
2021-04-27 14:24:15.141  INFO 20668 --- [nio-8088-exec-1] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Start completed.
sendStatus---SEND_OK
localTXState---UNKNOW
2021-04-27 14:24:59.156  INFO 20668 --- [pool-1-thread-1] com.example.Listener.OrderTXMsgListener  : >>>> TX message listener check local transaction, message=[123, 34, 105, 100, 34, 58, 110, 117, 108, 108, 44, 34, 117, 115, 101, 114, 73, 100, 34, 58, 49, 44, 34, 111, 114, 100, 101, 114, 84, 121, 112, 101, 34, 58, 110, 117, 108, 108, 44, 34, 111, 114, 100, 101, 114, 78, 111, 34, 58, 34, 49, 49, 49, 49, 49, 34, 44, 34, 112, 114, 105, 99, 101, 34, 58, 50, 48, 48, 46, 48, 125] <<<<
接收到消息，开始消费..OrderType:null,OrderNO:11111

通过日志分析可以看出，在执行完本地事务方法之后，返回的本地事务状态是UNKNOW，接着执行检查本地事务方法，如果查询到有这条订单的order_no的数据 返回COMMIT 消费者继续消费信息，和我们的预期是一样的。

2.3 模仿本地事务回滚

简单改造下执行本地事务的方法，让直接返回RocketMQLocalTransactionState.ROLLBACK，表示该消息将被删除，不允许被消费。

/**
     * 步骤二：
     * 描述：mq收到事务消息后，开始执行本地事务
     * @Transactional：开启本地事务
     * @param msg
     * @param arg
     * @return
     */

    @Override
    public RocketMQLocalTransactionState executeLocalTransaction(Message msg, Object arg) {
        log.info(">>>> TX message listener execute local transaction, message={},args={} <<<<",msg,arg);
        // 执行本地事务
        RocketMQLocalTransactionState result = RocketMQLocalTransactionState.COMMIT;
        try {
            String jsonString = new String((byte[]) msg.getPayload(), StandardCharsets.UTF_8);
            OrderEntity order = GSON.fromJson(jsonString, OrderEntity.class);
            orderService.addOrder(order);
        } catch (Exception e) {
            log.error(">>>> exception message={} <<<<",e.getMessage());
            result = RocketMQLocalTransactionState.UNKNOWN;
        }
        return RocketMQLocalTransactionState.ROLLBACK;
    }

再次调用一下接口，查看日志输出如下：

通过日志分析可以看出，在执行完本地事务方法之后，返回的本地事务状态是ROLLBACK，消费者并没有消费这条消息

这里你可能质疑，前面的发送和本地事务都没啥问题，要么commit要么rollback，但如果这里消费失败怎么办呢？其实这里会产生问题的几率几乎不存在，首先RocketMQ就是高可用的，要真的你系统很庞大很庞大，你可以集群；再者，这里消费成功与否，源码内部已做处理，只要没异常，就会进行消费，而且它也有重试机制；最后，这里消费逻辑你可以扩展，当消费不成功时，你可以把该记录保存下来，定时提醒或人工去处理

我模拟了下消费端消费抛出个异常，并发消费模型中，消息消费失败默认会重试 16 次(16次可能是之前的版本，我测试的4.8.0 可以重试34次)，每一次的间隔时间不一样；而顺序消费，如果一条消息消费失败，则会一直消费，直到消费成功。故在顺序消费使用过程中，应用程序需要区分系统异常、业务异常，如果是不符合业务规则导致的异常，则重试多少次都无法消费成功，这个时候一定要告警机制，及时进行人为干预，否则消费会积压会发现消费端会一直重试进行消费，由此可见确实 这里消费逻辑你可以扩展，当消费不成功时，你可以把该记录保存下来，定时提醒或人工去处理

好了RocketMQ的事务消息先演示到这里 有任何不对的地方，评论区见！

最后配个图