分布式事务：基于rabbitmq可靠消息最终一致性

最新推荐文章于 2024-09-11 09:30:00 发布
最新推荐文章于 2024-09-11 09:30:00 发布
阅读量2.3k 收藏 16
点赞数 5
文章标签： 分布式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/anyincc125/article/details/111246254
版权

面临问题

随着分布式服务架构的流行与普及，原来在单体应用中执行的多个逻辑操作，现在被拆分成了多个服务之间的远程调用，随之而来挑战就是分布式事务问题，多个服务之间使用自己单独维护的数据库，它们彼此之间不在同一个事务中，假如A执行成功了，B执行却失败了，而A的事务此时已经提交，无法回滚，那么最终就会导致两边数据不一致性的问题。

设计理念

基于rabbitmq可靠消息的最终一致性，需要保证以下要素：

  1. 确认生产者一定要将数据投递到MQ服务器中，采用本地事务消息、定时任务、消息确认机制。

  2. MQ消费者消息能够正确消费消息，采用手动ACK模式、方法幂等性、重试机制。

  3. 始终不能消费的消息进行人工通知处理

时序图

优缺点

优点：

  1. 简化：长事务通过消息服务拆分成小事务，事务形态变得简单，
  2. 利用队列进行进行通讯，具有削峰填谷的作用。
  3. 性能提升：事务被拆解，实现控制资源锁的粒度最小化。
  4. 数据最终一致性：基于可靠的消息服务，部分保证数据的最终一致性。

缺点：

  1. 依赖可靠的消息服务器，通常需要改造或封装消息服务器
  2. “从业务流程”只能成功。如果“从业务流程”失败，需要人工或其他附加处理流程。 

适用场景：

  1. 柔性事务：数据最终一致性
  2. 适用于分布式事务的提交或回滚只取决于事务发起方的业务需求、其他数据源的数据变更跟随事务发起方进行的业务场景。仅适用于 “主、从业务” 的数据一致性要求不高的场景

注意事项：

  1. 需要确保“从业务”处理的幂等性。

 

依赖配置

  • 重试机制使用了rabbitMQ的延时插件rabbitmq_delayed_message_exchange

配置说明

# rabbitmq

spring:

  rabbitmq:

    #开启 confirm 确认机制

    publisher-confirms: true

    #设置消费端手动 ack

    listener:

      simple:

        acknowledge-mode: manual

 

开发示例

  • 表结构
-- 发送端
CREATE TABLE `t_broker_msg_log`  (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `msg_id` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '消息id',
  `msg_content` varchar(6000) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '消息内容',
  `status` int(11) NOT NULL DEFAULT 0 COMMENT '处理状态 0发送中，1发送成功，2发送失败',
  `send_count` int(11) NOT NULL DEFAULT 0 COMMENT '发送次数',
  `remark` varchar(2000) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT '' COMMENT '备注',
  `create_time` datetime(0) NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  PRIMARY KEY (`id`) USING BTREE,
  INDEX `t_order_pay_ground_sn`(`msg_id`, `status`, `try_count`) USING BTREE
) ENGINE = InnoDB COMMENT = '消息日志表';
-- 接收端
CREATE TABLE `t_broker_msg_ground`  (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `msg_id` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '消息编号',
  `msg_content` varchar(6000) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '消息内容',
  `status` int(11) NOT NULL DEFAULT 0 COMMENT '处理状态 0待处理，1处理成功，2处理失败',
  `process_count` int(11) NOT NULL DEFAULT 0 COMMENT '处理次数',
  `remark` varchar(2000) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT '' COMMENT '备注',
  `create_time` datetime(0) NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  PRIMARY KEY (`id`) USING BTREE,
  INDEX `t_order_pay_ground_sn`(`msg_id`, `status`, `process_count`) USING BTREE
) ENGINE = InnoDB COMMENT = '消息落地表' ;


-- 分割
CREATE TABLE `t_user`  (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `uname` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '用户名',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB COMMENT = '用户表' ;

CREATE TABLE `t_user_exp`  (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `u_name` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '用户名',
  `num` int(11) NOT NULL DEFAULT 0 COMMENT '积分',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB COMMENT = '会员积分表' ;
  • 核心源代码

消息发送端可靠性确认

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.support.CorrelationData;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;

/**
 * @description: 自定义消息发送确认的回调
 * @author: anhj
 * @create: 2020/7/20
 **/
@Component
public class CustomConfirmCallback implements RabbitTemplate.ConfirmCallback {

    protected final Log logger = LogFactory.getLog(this.getClass());

    @Resource
    private RabbitTemplate rabbitTemplate;
    @Resource
    private BrokerMsgLogMapper brokerMsgLogMapper;

    /**
     * PostConstruct: 用于在依赖关系注入完成之后需要执行的方法上，以执行任何初始化.
     */
    @PostConstruct
    public void init() {
        logger.info("ConfirmCallback");
        rabbitTemplate.setConfirmCallback(this);
    }

    /**
     * 如果消息没有到达交换机,则该方法中isSendSuccess = false,error为错误信息;
     * 如果消息正确到达交换机,则该方法中isSendSuccess = true;
     */
    @Override
    public void confirm(CorrelationData correlationData, boolean isSendSuccess, String error) {
        logger.info("isSendSuccess=" + isSendSuccess);
        String messageId = correlationData.getId();
        if (isSendSuccess) {
            //如果消息到达MQ Broker，更新消息
            brokerMsgLogMapper.changeBrokerMsgStatus(messageId, Constants.MSG_SEND_SUCCESS);
        }
    }

}
import com.alibaba.fastjson.JSONObject;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.support.CorrelationData;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

/**
 * @description: 生产端
 * @author: anhj
 * @create: 2020/7/20
 **/
@Component
public class Producer {
    @Resource
    private RabbitTemplate rabbitTemplate;

    public void send(String msgId, Object msgContent, String routeKey) throws Exception {
        //消息唯一ID,,低版本的mq消费端取不到ID
         CorrelationData correlationData = new CorrelationData(msgId);

        // 封装消息ID
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("msgId",msgId);
        jsonObject.put("msgContent",msgContent);
        //正常发送消息
        rabbitTemplate.convertAndSend(Constants.EXCHANGE_NAME, routeKey, jsonObject.toJSONString(), correlationData);
    }
}

消费端

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.rabbitmq.client.Channel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.io.IOException;

/**
 * 用户注册消息
 *
 * @author andy an
 * @since 2020/07/20 11:35
 */
@Component
public class UserRegReceiver {
    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @Resource
    private UserRegService userRegService;

    /**
     * 用户注册
     */
    @RabbitListener(queues = {Constants.QUEUE_NAME})
    public void receive(Message message, Channel channel) {
        String msg = new String(message.getBody());
        logger.info("message={}", msg);
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        String msgId = "";
        String msgContent = "";
        User userInfo = null;

        try {
            msgContent = JSON.parseObject(msg, JSONObject.class).getString("msgContent");
            msgId = JSON.parseObject(msg, JSONObject.class).getString("msgId");
            // 解析消息
            userInfo = JSON.parseObject(msgContent, User.class);
        } catch (Exception e) {
            // 无法处理的消息,直接抛弃
            ackMsg(channel, deliveryTag, msg);
            return;
        }

        // 幂等性校验
        if (userRegService.idempotent(msgId)) {
            // 重复消息,直接抛弃
            ackMsg(channel, deliveryTag, msg);
            return;
        }

        // 落地到表中
        try {
            userRegService.ground(msgId, msgContent);
        } catch (Exception e) {
            // 失败,数据已经存在
            logger.error("ground err", e);
            ackMsg(channel, deliveryTag, msg);
            return;
        }
        // 确认消费
        ackMsg(channel, deliveryTag, msg);

        // 异步处理落地数据
        userRegService.process(userInfo, msgId);

    }


    /**
     * 确认消息
     */
    private void ackMsg(Channel channel, long deliveryTag, String msg) {
        try {
            channel.basicAck(deliveryTag, false);
        } catch (IOException e1) {
            logger.error("basicAck msg={}", msg);
            logger.error("basicAck err", e1);
        }
    }

}

import com.rabbitmq.client.Channel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.*;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.io.IOException;

/**
 * 重试消息接收
 *
 * @author anhj
 * @since 2020/12/03
 */
@Component
public class RetryReceiver {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @Resource
    private UserRegService userRegService;

    /**
     * 提现失败信息
     */
    @RabbitListener(
            bindings = @QueueBinding(
                    value = @Queue(RETRY_QUEUE_NAME),
                    exchange = @Exchange(value = RETRY_QUEUE_NAME, type = "x-delayed-message",
                            arguments = @Argument(name = "x-delayed-type", value = "direct")
                    ),
                    key = "retry"
            )
    )
    public void receive(Message message, Channel channel) {
        String msg = new String(message.getBody());
        logger.info("message={}", msg);
        long deliveryTag = message.getMessageProperties().getDeliveryTag();

        // 提现重试
        try {
            userRegService.retry(msg);
        } catch (Exception e) {
            // 进行下次重试
            logger.error(e.getMessage(),e);
        }

        // 确认消费
        ackMsg(channel, deliveryTag, msg);
    }

    /**
     * 确认消息
     */
    private void ackMsg(Channel channel, long deliveryTag,String msg) {
        try {
            channel.basicAck(deliveryTag, false);
        } catch (IOException e1) {
            logger.error("basicAck msg={}", msg);
            logger.error("basicAck err={}", e1);
        }
    }
}

 

anyincc125
关注
分布式事务
weixin_49201230的博客
12-24 159
分布式事务 1.什么是分布式事务 分布式系统会把一个应用系统拆分为可独立部署的多个服务，因此需要服务与服务之间远程协作才能完成事务操作，这种分布式系统环境下由不同的服务之间通过网络远程协作完成事务称之为分布式事务，例如用户注册送积分事务、创建订单减库存事务，银行转账事务等都是分布式事务。 2.RocketMQ可靠消息最终一致性 2.1.为什么要使用可靠消息最终一致性 ​ 在实际系统的开发过程中，可能服务间的调用是异步的。也就是说，一个服务发送一个消息给 MQ，即消息中间件，比如RocketMQ、
分布式事务 ：可靠消息最终一致性方案
m0_67322837的博客
08-07 116
严格意义上的事务应该是具备原子性、一致性、隔离性和持久性，简称ACID。原子性（Atomicity），可以理解为一个事务内的所有操作要么都执行，要么都不执行。一致性（Consistency），可以理解为数据是满足完整性约束的，也就是不会存在中间状态的数据，比如你钱包有100，我钱包有100，你给我打50块，此时你钱包的钱应该是50，我钱包的钱应该是150，不会存在我钱加了，你钱没扣的中间状态。隔离性（Isolation）...
Springboot2.X基于可靠消息rabbitmq最终一致性分布式事务+分布式全局唯一ID生成器
08-04
1、代码未实现部分      a、积分、红包相关代码未实现，按照下单逻辑操作即可      b、quatz调度未实现，这个相当简单，可以通过dubbo等rpc方式、或者httpclient方式进行远程调度，相关代码：            https://download.csdn.net/download/qq_22049773/12540998      c、其他均已实现      d、分布式全局ID生成器，ID生成非绝对递增有序，是趋向有序，这一点如果能接受，可以直接copy使用 2、事务回滚机制说明        a、每个消费端的事务处理都由本地事务负责        b、基于下单队列消费端临时表，查询红包、积分两个队列消费端的临时表中该订单的处理的状态，如果全部为消费成功，则更新业务订单表中的订单状态由  下单中  --》 待付款并删除所有临时表数据，如果非全部消费成功，则将定性为异常单并写入补单队列，并删除所有临时表数据。该逻辑有定时调度完成。
RabbitMQ消息可靠性传输示例
weixiaohuai的博客
07-28 1003
一、简介 生产端的可靠性投递： 保障消息的成功发出； 保障MQ节点的成功接收； 发送端收到MQ节点(Broker) 确认应答； 完善的消息补偿机制； 在实际项目中某些场景下，必须保证消息不会出现丢失情况，这时候就需要我们对消息可靠性传输解决方法有所认识，才能在各种特殊情况下不会出现消息丢失、消息多发现象等。生产者可靠性传输有两种方案： 消息落库，对消息状态进行打标 消息的延迟投递，做...
RabbitMQ 的事务消息了解吗【RabbitMQ 事务消息实战】
最新发布
weixin_42118323的博客
09-11 1617
我们知道 RabbitMQ 保证消息一定会发送成功，一般有两种方式，分别是 Publisher Confirm 机制和事务消息，上一篇我们分享了如果使用 RabbitMQ Publisher Confirm 机制来保证消息一定发送成功，本篇我们来分享使用 RabbitMQ 事务消息保证消息一定会发送成功。
RabbitMQ可靠消息最终一致性
QAQnullPoint的博客
09-02 1609
通俗来讲就是上游服务需要保证消息一定会发出给MQ，下游服务一定会接收到消息，并且在成功消费掉消息之后，返回ack。这个方案是通过消息中间件完成的。
使用RabbitMQ+延迟队列实现分布式事务的最终一致性方案
04-13
在本方案中，我们将利用RabbitMQ的延迟队列特性来实现在订单和库存系统中的分布式事务最终一致性。 RabbitMQ是基于AMQP（Advanced Message Queuing Protocol）的消息中间件，它提供了一种可靠的消息传递机制，使得...
基于rabbitmq实现的分布式事务解决方案是独立消息服务的最终一致性案例源码.zip
03-03
在这个场景中，我们关注的是基于RabbitMQ实现的分布式事务解决方案，它是一种独立消息服务确保最终一致性的案例。RabbitMQ是广泛应用的消息中间件，用于解耦应用程序，使得它们可以通过消息进行通信，而无需直接交互...
Distributed-transaction:基于消息队列最终一致性实现的分布式事务demo
04-29
本项目"分布式事务：基于消息队列最终一致性实现的分布式事务demo"提供了如何利用消息队列来处理分布式事务的一种实践方法。下面我们将深入探讨这一主题。 首先，我们需要理解什么是分布式事务。分布式事务是在...
RabbitMQ保证消息的一致性解决方案
AstarCloud
05-07 1万+
RabbitMQ保证消息的一致性 一、采用confirm消息确认机制及return返回机制 确保消息发送成功 二、将队列以及消息设置持久化 保证rabbitmq突然宕机消息仍然存在 三、手动确认接收消息方式 消息处理失败拒收重回队列 1. yml配置 spring: rabbitmq: host: 10.134.22.232 port: 5672 username: guest password: guest #采用confirm以及r
消息最终一致性解决方案之RabbitMQ实现
热门推荐
wang386476890的专栏
04-16 1万+
RabbitMQ遵循了AMQP规范，用消息确认机制来保证：只要消息发送，就能确保被消费者消费来做到了消息最终一致性。而且开源，文档还异常丰富，貌似是实现分布式事务的良好载体 6.1 RabbitMQ消息确认机制 rabbitmq的整个发送过程如下 1. 生产者发送消息到消息服务 2. 如果消息落地持久化完成，则返回一个标志给生产者。生产者拿到这个确认后，才能放心的说消息终于成功发到消息服务了。否则进入异常处理流程。 rabbitTemplate.setConfirmCallback( (
RabbitMq | 解决分布式事务（最终一致性原理）
俺老孙来也
03-19 3222
rabbitMQ解决分布式事务原理： 采用最终一致性原理。 需要保证以下三要素 1、确认生产者一定要将数据投递到MQ服务器中（采用MQ消息确认机制） 2、MQ消费者消息能够正确消费消息，采用手动ACK模式（注意重试幂等性问题） 3、如何保证第一个事务先执行，采用补偿机制，在创建一个补单消费者进行监听，如果订单没有创建成功，进行补单。 外卖点餐项目中，订单服务中产生订单，生成订单号。 此时需要调用...
基于RabbitMQ的分布式事务最终一致性解决方案
qq_40857365的博客
04-22 3244
1. 分布式事务 所谓事务，通俗一点讲就是一系列操作要么同时成功，要么同时失败。而分布式事务就是这一系列的操作在不同的节点上，那要如何保证事务的ACID特性呢。 原子性（atomicity）。一个事务是一个不可分割的工作单位，事务中包括的操作要么都成功，要么都失败。 一致性（consistency）。事务必须是使数据库从一个一致性状态变到另一个一致性状态。一致性与原子性是密切相关的。 隔离性（isolation）。一个事务的执行不能被其他事务干扰。即一个事务内部的操作及使用的数据对并发的其他事务
分布式事务之rabbitMQ最终一致性
程序员
05-26 1万+
一般的大型电商网站都会面临的问题:分布式事务,在面临分布式微服务等项目使用传统的单一事务已经无法满足，解决分布式事务的方案也比较多，有TCC事务补偿（基于2PC的实现）、2PC（两阶段提交）、3PC（三阶段提交）等，框架有JTA atomiks等。很多公司也有自己的分布式事务解决方案，比如最开始支付宝的XTS等 像JTA atomiks等2PC的方案效率并不高，中间需要一个协调者，并且是同步的，...
rabbitmq ,mq可靠消息最终一致性方案的核心流程
lixiangfei4的博客
02-14 1042
①上游服务投递消息 如果要实现可靠消息最终一致性方案，一般你可以自己写一个可靠消息服务，实现一些业务逻辑。 首先，上游服务需要发送一条消息给可靠消息服务。这条消息说白了，你可以认为是对下游服务一个接口的调用，里面包含了对应的一些请求参数。 然后，可靠消息服务就得把这条消息存储到自己的数据库里去，状态为“待确认”。 接着，上游服务就可以执行自己本地的数据库操作，根据自己的执行结果，再次调用可靠消息服...
Rabbit MQ消息一致性的解决方案
Aldnoah
12-27 927
1. 如何保证消息正确发送至RMQ 发送方确认模式 信道设置为confirm模式 投放到目的队列的时候回返回消息的唯一ID 如果报错会得到 not ack消息 接收方确认机制 消费者接收且确认后,才能安全的把消息删除 如果接收未确认且断开连接则重新分发 如果接收未确认且连接则认定繁忙 2. 如何避免重复投递或消费 在消息生产时, 生成inner - msg ...
RabbitMq的最终一致性分布式事务
行云的博客
09-28 687
rabbitmq的使用
RabbitMQ解决分布式事务：五步法详解
通过以上步骤，RabbitMQ能够帮助实现分布式事务中的最终一致性，即使在系统故障或网络中断的情况下，也能保证数据的正确处理。在具体实施时，重要的是理解业务需求和场景，选择适合的解决方案，而非简单地复制代码。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值