Spring解决RocketMQ发消息与MySQL事务一致性

已于 2023-09-25 15:54:05 修改
阅读量682 收藏
点赞数
分类专栏： java 文章标签： spring java-rocketmq rocketmq
于 2022-09-23 09:45:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xxzblog/article/details/126997214
版权

场景

  1. 用户订单并支付
  2. 发送消息开通查看文章权限
// 伪代码
@Transactional(rollbackFor=Exception.class)
public void pay(long uid, String orderNO) {
  Order order = orderService.selectOrder(uid, orderNO)
  if (order != null) {
    String status = "paid";
    orderDao.updateStatus(uid, orderNo, status);
    
    rocketMQTemplate.send("order:status", message(uid, orderNo, order.itemId, status));
  }
}

public class OrderStatusArticleListener implements RocketMQListener {
    public void onMessage(message) {
        Order order = orderService.selectOrder(message.uid, message.orderNo)
        if (order == null) {
           throw new RuntimeException("order not found. " + message.orderNo)
        }
        if (order.status != "paid") {
            throw new RuntimeException("order not paid. " + message.orderNo)
        }
        // 授权
        articleService.authorize(message.uid, message.itemId)
    }
}

上面的例子中会出现消费者查询订单的时候是未支付的状态。

为什么会这样呢？

这是因为我们在spring的事务中同步发送消息导致事务还没有提交。消息已经到了消费者端开始消费了。

解决：

  1. 增加消息表，与事务同步落库，标记为待处理
  2. MQ 发送成功
  3. MQ 的回调处理落库的数据，标记为处理完成

由于是在Spring的环境中，我们使用Spring的TransactionSynchronizationManager#registerSynchronization

if (TransactionSynchronizationManager.isSynchronizationActive()) {
    TransactionSynchronizationManager.registerSynchronization(new MQTransactionSynchronization(
            rocketMQTemplate, destination, message, timeout, delayLevel
    ));
}

我们自定义一个TransactionSynchronization名字叫MQTransactionSynchronization

@Slf4j
public class MQTransactionSynchronization implements TransactionSynchronization {
    private DataSource dataSource;
    private ConnectionHolder connectionHolder;
    private String id;
    private RocketMQTemplate rocketMQTemplate;
    private String destination;
    private Message message;
    private long timeout;
    private int delayLevel;
    
    public MQTransactionSynchronization(RocketMQTemplate  rocketMQTemplate, String destination, Message  message, long  timeout, int delayLevel) {
        this.rocketMQTemplate = rocketMQTemplate;
        this.destination = destination;
        this.message = message;
        this.timeout = timeout;
        this.delayLevel = delayLevel;
    }
    
    @Override
    public void beforeCompletion() {}
    
    @Override
    public void beforeCommit(boolean readOnly) {
        Map<Object, Object> resourceMap = TransactionSynchronizationManager.getResourceMap();
        for (Map.Entry<Object, Object> entry : resourceMap.entrySet()) {
            Object key = entry.getKey();
            Object value = entry.getValue();
            if (value instanceof ConnectionHolder) {
                this.dataSource = (DataSource) key;
                this.connectionHolder = (ConnectionHolder) value;
                break;
            }
        }
         if (connectionHolder == null) {
            log.warn("connectionHolder is null");
            return;
        }
		this.id = UUID.randomUUID().toString();
		final String mqTemplateName = ApplicationContextUtils.findBeanName(rocketMQTemplate.getClass(), rocketMQTemplate);
		MqMsgDao.insertMsg(connectionHolder, id, mqTemplateName, destination, message, timeout, delayLevel);
    }
    @Override
    public void afterCommit() {
        log.debug("afterCommit {}", TransactionSynchronizationManager.getCurrentTransactionName());
        try {
            rocketMQTemplate.syncSend(destination, message, timeout, delayLevel);
            MqMsgDao.deleteMsgById(dataSource, this.id);
        } catch (Exception e) {
            log.error("mq send message failed. topic:[{}], message:[{}]", destination, message, e);
        }
    }
    @Override
    public void afterCompletion(int status) {
        log.debug("afterCompletion {} : {}", TransactionSynchronizationManager.getCurrentTransactionName(), status);
        rocketMQTemplate = null;
        destination = null;
        message = null;
        connectionHolder = null;
        dataSource = null;
        id = null;
    }
}

@Slf4j
public class MqMsgDao {
    public static final String STATUS_NEW = "NEW";
    public static final Integer MAX_RETRY_TIMES = 5;
    private static final JsonMapper MAPPER = JsonMapper.builder()
            .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)
            .enable(MapperFeature.PROPAGATE_TRANSIENT_MARKER)
            .build();
    
    public static List<MqMsg> listMsg(DataSource dataSource) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            conn = dataSource.getConnection();
            ps = conn.prepareStatement("select * from tb_mq_msg where status = ? and retry_times < ? limit 100");
            int i = 0;
            ps.setObject(++i, STATUS_NEW);
            ps.setObject(++i, MAX_RETRY_TIMES);
            rs = ps.executeQuery();
            List<MqMsg> list = new ArrayList<>(100);
            while (rs.next()) {
                MqMsg mqMsg = new MqMsg();
                mqMsg.setId(rs.getString("id"));
                mqMsg.setStatus(rs.getString("status"));
                mqMsg.setMqTemplateName(rs.getString("mq_template_name"));
                mqMsg.setMqDestination(rs.getString("mq_destination"));
                mqMsg.setMqTimeout(rs.getLong("mq_timeout"));
                mqMsg.setMqDelayLevel(rs.getInt("mq_delay_level"));
                Map<String, Object> map = fromJson(rs.getString("payload"));
                GenericMessage<Object> message = new GenericMessage<>(map.get("payload"), (Map<String, Object>) map.get("headers"));
                mqMsg.setMessage(message);
                mqMsg.setRetryTimes(rs.getInt("retry_times"));
                mqMsg.setCreateTime(rs.getTimestamp("create_time"));
                mqMsg.setUpdateTime(rs.getTimestamp("update_time"));
                list.add(mqMsg);
            }
            return list;
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            close(rs, ps, conn);
        }
    }
    
    public static void insertMsg(ConnectionHolder connectionHolder,
                                 String id,
                                 String mqTemplateName,
                                 String mqDestination,
                                 Message message,
                                 long mqTimeout,
                                 int mqDelayLevel) {
         Connection connection = connectionHolder.getConnection();
         PreparedStatement ps = null;
         Map<String, Object> payload = new HashMap<>();
         payload.put("payload", message.getPayload());
         payload.put("headers", message.getHeaders());

        try {
            ps = connection.prepareStatement("insert into tb_mq_msg values(?,?,?,?,?,?,?,?,?,?)");
            Date now = new Date();
            int i = 0;
            ps.setObject(++i, id);
            ps.setObject(++i, STATUS_NEW);
            ps.setObject(++i, mqTemplateName);
            ps.setObject(++i, mqDestination);
            ps.setObject(++i, mqTimeout);
            ps.setObject(++i, mqDelayLevel);
            ps.setObject(++i, toJson(payload));
            ps.setObject(++i, 0);
            ps.setObject(++i, now);
            ps.setObject(++i, now);
            int affect = ps.executeUpdate();
            if (affect <= 0) {
                throw new RuntimeException("insert mq msg affect : " + affect);
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            close(ps);
        }
    }
    
    public static void updateMsgRetryTimes(DataSource dataSource, String id) {
        Connection conn = null;
        PreparedStatement ps = null;
        try {
            conn = dataSource.getConnection();
            ps = conn.prepareStatement("update tb_mq_msg set retry_times = retry_times + 1, update_time = ? where id = ?");
            int i = 0;
            ps.setObject(++i, new Date());
            ps.setObject(++i, id);
            int affect = ps.executeUpdate();
            if (affect <= 0) {
                log.error("update mq msg retry_times failed. id:[{}]", id);
                throw new RuntimeException("update mq msg retry_times failed. id:" + id);
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            close(ps, conn);
        }
    }
    
    public static void deleteMsgById(DataSource dataSource, String id) {
        Connection conn = null;
        PreparedStatement ps = null;
        try {
            conn = dataSource.getConnection();
            ps = conn.prepareStatement("delete from tb_mq_msg where id = ?");
            int i = 0;
            ps.setObject(++i, id);
            int affect = ps.executeUpdate();
            if (affect <= 0) {
                log.error("delete mq msg failed. id:[{}]", id);
                throw new RuntimeException("delete mq msg failed. id:" + id);
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            close(ps, conn);
        }
    }
    
    private static void close(AutoCloseable... closeables) {
        if (closeables != null && closeables.length > 0) {
            for (AutoCloseable closeable : closeables) {
                if (closeable != null) {
                    try {
                        closeable.close();
                    } catch (Exception ignore) {
                    }
                }
            }
        }
    }
    
    private static String toJson(Object payload) {
        try {
            return MAPPER.writeValueAsString(payload);
        } catch (JsonProcessingException e) {
            throw new RuntimeException(e);
        }
    }
    
    private static Map<String, Object> fromJson(String payload) {
        try {
            return MAPPER.readValue(payload, new TypeReference<Map<String, Object>>() {
            });
        } catch (JsonProcessingException e) {
            throw new RuntimeException(e);
        }
    }
}

@Slf4j
@Component
public class ApplicationContextUtils implements ApplicationContextAware {

    private static ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        ApplicationContextUtils.applicationContext = applicationContext;
        log.info("=== ApplicationContextUtils init ===");
    }

    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }
   

    public static Object getBean(String name) {
        return getApplicationContext().getBean(name);
    }

    public static <T> T getBean(Class<T> clazz) {
        return getApplicationContext().getBean(clazz);
    }

    public static <T> T getBean(String name, Class<T> clazz) {
        return getApplicationContext().getBean(name, clazz);
    }

    public static String findBeanName(Class clazz, Object obj) {
        Map<String, Object> beans = getApplicationContext().getBeansOfType(clazz);
        for (Map.Entry<String, Object> entry : beans.entrySet()) {
            Object value = entry.getValue();
            if (value == obj) {
                return entry.getKey();
            }
        }
        return null;
    }

}

解决消息发送失败，使用定时任务重试

@Slf4j
@Component
pubilc class MqMsgSchedule implements InitializingBean {
    private static final ScheduledThreadPoolExecutor EXECUTOR =
            new ScheduledThreadPoolExecutor(1, new ThreadFactory() {
                AtomicInteger threadCount = new AtomicInteger(0);
                @Override
                public Thread newThread(Runnable r) {
                    return new Thread(r, "mq-msg-" + threadCount.getAndIncrement() + "-" + r.hashCode());
                }
            }, new ThreadPoolExecutor.DiscardPolicy());

    @Override
    public void afterPropertiesSet() throws Exception {
        EXECUTOR.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                retrySendTask();
            }
        }, 0, 5000, TimeUnit.MILLISECONDS);
    }

    public void retrySendTask() {     
        try {
            Map<String, DataSource> beans = ApplicationContextUtils.getApplicationContext().getBeansOfType(DataSource.class);
            for (Map.Entry<String, DataSource> entry : beans.entrySet()) {
                List<MqMsg> mqMsgList = MqMsgDao.listMsg(entry.getValue());
                for (MqMsg mqMsg : mqMsgList) {
                    if (mqMsg.getRetryTimes() >= MqMsgDao.MAX_RETRY_TIMES) { 
                        log.error("mqMsg retry times reach {}, id:[{}]", MqMsgDao.MAX_RETRY_TIMES, mqMsg.getId());
                    } else {
                        RocketMQTemplate rocketMQTemplate = (RocketMQTemplate) ApplicationContextUtils.getBean(mqMsg.getMqTemplateName());
                        try {
                            rocketMQTemplate.syncSend(mqMsg.getMqDestination(),
                                    mqMsg.getMessage(),
                                    mqMsg.getMqTimeout(),
                                    mqMsg.getMqDelayLevel());
                            MqMsgDao.deleteMsgById(entry.getValue(), mqMsg.getId());
                        } catch (Exception e) {
                            MqMsgDao.updateMsgRetryTimes(entry.getValue(), mqMsg.getId());
                            log.error("[task] mq send failed. mqMsg:[{}]", mqMsg, e);
                        }
                    }
                }
            }
        } catch (Exception e) {
            log.error("task error.", e);
        }
    }
}

提供调用类

@Slf4j
public final class MQTransactionHelper {

    public static void syncSend(final RocketMQTemplate rocketMQTemplate,
                                final String destination,
                                final Message message) {
        syncSend(rocketMQTemplate, destination, message,
                rocketMQTemplate.getProducer().getSendMsgTimeout(), 0);
    }

    public static void syncSend(final RocketMQTemplate rocketMQTemplate,
                                final String destination,
                                final Message message,
                                final long timeout,
                                final int delayLevel) {
        if (TransactionSynchronizationManager.isSynchronizationActive()) {
            TransactionSynchronizationManager.registerSynchronization(new MQTransactionSynchronization(
                    rocketMQTemplate, destination, message, timeout, delayLevel
            ));
        }
    }

}

数据库

CREATE TABLE `tb_mq_msg` (
  `id` VARCHAR(64) NOT NULL,
  `status` VARCHAR(20) NOT NULL COMMENT '事件状态(待发布NEW)',
  `mq_template_name` VARCHAR(1000) NOT NULL,
  `mq_destination` VARCHAR(1000) NOT NULL,
  `mq_timeout` BIGINT NOT NULL,
  `mq_delay_level` INT NOT NULL,
  `payload` TEXT NOT NULL,
  `retry_times` INT NOT NULL,
  `create_time` DATETIME NOT NULL,
  `update_time` DATETIME NOT NULL,
  PRIMARY KEY (`id`),
  KEY `idx_status` (`status`)
) ENGINE=INNODB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;

源码：https://github.com/jsbxyyx/rmq-transaction

RocketMQ系列（七）事务消息（数据库|最终一致性）
DN金猿的博客
02-20 925
终于到了今天了，终于要讲RocketMQ最牛X的功能了，那就是事务消息。为什么事务消息被吹的比较热呢？近几年微服务大行其道，整个系统被切成了多个服务，每个服务掌管着一个数据库。那么多个数据库之间的数据一致性就成了问题，虽然有像XA这种强一致性事务的支持，但是这种强一致性在互联网的应用中并不适合，人们还是更倾向于使用最终一致性的解决方案，在最终一致性的解决方案中，使用MQ保证各个系统之间的数据一致性又是首选。 RocketMQ为我们提供了事务消息的功能，它使得我们投放消息和其他的一些操作保持一个整体的原子性
SpringCloud + RocketMQ实现可靠消息最终一致性事务
weixiaohuai的博客
12-31 764
目录 一、概述 二、案例说明和数据库、表准备 三、下载安装RocketMQ并启动 四、搭建中国建设银行CCB微服务 五、搭建中国工商银行ICBC微服务 六、测试转账 七、总结 一、概述 前面一篇文章介绍了RocketMQ实现可靠消息最终一致性事务的整体流程，大部分都是理论知识，本篇文章我们将结合前面我们使用过的【银行转账案例】详细说明如何利用RocketMQ实现可靠消息最终一致性事务。 二、案例说明和数据库、表准备 案例： 张三【中国建设银行】给李四【中国工商银行】转账 说明：张三和
RocketMQ与MYSQL事务消息整合
dianhe7741的博客
07-09 507
1、基础理论知识篇“两阶段提交”如果你了解可以跳过这段，当然如果你想深入了解你可以购买相关书籍或去搜索相关资料阅读 　　两阶段提交分为 正常提交和异常提交或异常回滚 上面是正常提交的示意图，协调者发起预提交请求，参与者回复成功之后协调者再次发起commit请求，统一提交事物。事物结束。 如果这两阶段提交过程当中有任何一个请求出现异常就会回滚，如下流程...
MQ消息发送不在MySQL事务中，该如何保证一致性？
最新发布
大户影视的博客
03-12 1469
（RocketMQ 环境），结合幂等设计与重试机制，可有效解决 MQ 与数据库事务分离场景下的数据一致性问题。：任何 MQ（如 Kafka、RabbitMQ），需业务系统额外开发。：实时性略低（依赖 Binlog 解析延迟），需维护 CDC 服务。：强依赖 MQ 且支持事务消息的系统（如 RocketMQ）。：依赖特定 MQ（如 RocketMQ），技术栈受限。：高吞吐、解耦业务与消息发送的场景（如数据同步）。：需维护消息表，增加数据库压力。：与 MQ 无关，兼容性强。：原生支持，流程标准化。
mq和mysql事务一致性_GitHub - 事务最终一致性 - MQ保证消息一致性
weixin_35241867的博客
02-02 373
简介使用rabbitMq来简单实现分布式事务的最终一致性 版本如下：SpringCloud ： Finchley.SR1SpringBoot ： 2.0.4.RELEASEGradle ： 4.8项目结构启动顺序rabbitMq -> 注册中心 -> 网关 -> 订单 -> 支付整体流程生产者的逻辑1、订单入库2、消息记录入库3、发送消息(采用确认模式)4、mq收到消息之后...
rabbitmq消息发送的可靠性：结合mysql来保证消息投递的可靠性
print的博客
01-02 797
4. 设置一个定时任务：10秒执行一次. 根据（status）状态0并且重试时间（try_time）< sysdate()当前时间查询出List rabbitmqSendLogs消息的数量rabbitmqSendLogs。5.遍历所有消息rabbitmqSendLogs.forEach。定时任务，每隔10秒冲数据库查询，然后再从新投递到mq。数据表rabbitmq_send_log。接收rabbitmq消息的类。
SpringBoot中使用RocketMQ实现事务消息来保证分布式事务的一致性(有代码)
qq_21561833的博客
05-09 1300
分布式事务是分布式系统中非常常见的问题。是非常必要钱常见的。实现的方式也是多种多样。今天这个视频主要来分享一下RocketMQ实现事务消息来保证分布式事务的一致性。不知道大家使用过这种方式没有。这种分布式事务的原理其实和本地消息表一样。
RocketMQ 之事务消息
weixin_42118323的博客
10-19 1727
事务消息使用 rocketMQTemplate的sendMessageInTransaction 方法发送，返回结果为TransactionSendResult对象，该对象中包含了事务发送的状态、本地事务执行的状态等，生产者代码的核心逻辑是向 RocketMQ 发送事务消息，并执行本地事务，最后将本地事务的执行结果通知到 RocketMQ，返回结果为TransactionSendResult对象，该对象中包含了事务发送的状态、本地事务执行的状态等。将二阶段提交和本地事务绑定，实现全局提交结果的一致性。
RocketMQ实现可靠消息最终一致性
wry的博客
06-21 1614
RocketMQ实现可靠消息最终一致性 业务说明 本实例通过RocketMQ中间件实现可靠消息最终一致性分布式事务，模拟两个账户的转账交易过程。 两个账户在分别在不同的银行(张三在bank1、李四在bank2)，bank1、bank2是两个微服务。 交易过程是，张三 给李四转账指定金额。 上述交易步骤，张三扣减金额与给bank2发转账消息，两个操作必须是一个整体性的事务。 程序组成部分 数据库：MySQL-8.X （包括bank1和bank2 两个数据库） JDK:1.8.X 微服务框架：SpringBo
学会了，SpringCloud+RocketMQ实现分布式事务
a1472750149的博客
10-30 661
随着互联网公司的微服务越来越多，分布式事务已经成为了我们的经常使用的。所以我们来一步一步的实现基于RocketMQ的分布式事务。接下来，我们将要做的主题写出来。 RocketMQ的分布式事务结构和说明 搭建RocketMQ步骤 事务场景，然后准备工程，运行代码 　　一、RocketMQ的分布式事务结构和说明 　　我们通过下图来了解一下RocketMQ实现分布式事务的结构。采用半消息机制实现分布式事务，半消息顾名思义，就是发送方将消息发送到MQ中的Broker端，这个消息被标记
分布式事务（八）Spring Cloud微服务系统基于Rocketmq可靠消息最终一致性实现分布式事务...
10-26 192
项目源码： https://gitee.com/benwang6/rocketmq-dtx 安装搭建 Rocketmq 服务器 搭建单机 Rocketmq 服务器笔记： 《RocketMQ (一) 安装》 搭建双主双从同步复制 Rocketmq 服务器笔记： 《RocketMQ (二) 双主双从同步复制集群方案》 基于 Rocketmq 可靠消息的分布式事务方案原理 Roc...
解读 RocketMQ 应用 RocketMQ-MySQL
weichencui的专栏
04-19 869
1、框架说明 ​ 用于读取mysql的binlog日志文件，将日志文件发到rocketMq，消费端可以订阅主题，对消息进行处理。这种方式 可以使多个应用订阅数据库变更数据。各个应用根据自己的业务逻辑处理对应的数据表即可。 1、结构流程图 图解说明： ​ 1、mysql数据库开启Binary log操作日志记录功能，方便数据恢复，数据备份使用； ​ 2、通过中间件mysql-binlog-connector-java读取日志文件，将日志文件解析成JSON格式； ​
MQ如何保证消息的顺序一致性问题？
mengbotian的博客
06-01 857
【代码】MQ如何保证消息的顺序一致性问题？
SpringBoot整合RocketMQ事务/广播/顺序消息
关于代码的那些事
07-27 646
rocketmq默认发送的消息是进入多个消息队列，然后消费端多线程并发消费，所以默认情况，不是順序消费消息的；有時候，我们需要顺序消费一批消息，比如电商系统 订单创建、支付、完成操作，需要順序执行； RocketMQTemplate给我们提供了SendOrderly方法(有多個重载)，来实现发送顺序消息；包括以下： syncSendOrderly，发送同步顺序消息； asyncSendOrderly，发送异步顺序消息； sendOneWayOrderly，发送单向顺序消息； 一般我们用syncSe
SpringBoot发送RocketMQ事务消息
每天进步一点点...
04-25 1577
SpringBoot发送RocketMQ事务消息
mysql与缓存数据不一致解决-canal+mq方案
qq_17236715的博客
11-24 1448
利用canal+mq的解决业务上缓存不一致的方案，对于一些常用场景、跨多系统还是很方便的，吞吐量和延时性指标均不错，适用于高并发项目。并且能够做一次统一的缓存控制，有利于整理系统内无效代码，提高代码精简度。同时，缓存一致性方便基本不能够达到强一致，在考虑时需要将实际业务代入，思考一个全面的方案。
SpringBoot使用RocketMQ发送事务消息
w先生的博客
12-03 1134
事务消息的发送者可以将一系列的操作包装在一个事务中，如果整个事务的操作都成功执行，则消息被发送到消息队列，如果有任何一个操作失败，则消息被丢弃。事务消息的消费者可以通过回查机制来保证消息的最终一致性，即通过询问消息发送者的本地事务状态来判断是否需要提交或回滚。根据业务方返回的回查结果，Broker决定是否提交或回滚该事务消息，并将处理后的消息更新到实际的消息队列中，供消费者消费。在发送时，消息的属性中会添加。：已处理的半事务消息Topic，记录半事务消息的状态（如消息位移），便于后续处理。
RocketMQ与Spring Boot完美结合：事务消息的全面解析
weixin_48278764的博客
03-31 698
RocketMQ与Spring Boot完美结合：事务消息的全面解析
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值