SpringBoot整合消息中间件 RabbitMQ 第 10 篇 —— RabbitMQ 解决分布式事务（完结）

最新推荐文章于 2023-12-14 11:01:53 发布
最新推荐文章于 2023-12-14 11:01:53 发布
阅读量1k 收藏 37
点赞数 1
分类专栏： 学习消息中间件 文章标签： 队列 分布式 rabbitmq 解决分布式事务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BiandanLoveyou/article/details/115599825
版权

什么是分布式事务？

在微服务环境下，因为会根据不同的业务会拆分成不同的服务，比如会员服务、订单服务、商品服务等，每个服务都有自己独立的数据库，并且是独立运行，互不影响。在多数据源的情况下，两个服务相互通讯的时候，就会出现数据不一致的问题，从而出现分布式事务产生的原因。举例：某电商平台，用户先下单后，扣库存失败，那么将会导致超卖；如果下单不成功，扣库存成功，那么会导致少卖。

解决分布式事务基本思路

先了解一些概念：ACID原理、CAP、Base理论、柔性事务与刚性事务、理解最终一致性思想。

ACID（针对数据）：

数据库管理系统中事务(transaction)的四个特性（分析时根据首字母缩写依次解释）：

原子性（Atomicity） 原子性是指事务是一个不可再分割的工作单元，事务中的操作要么都发生，要么都不发生。

一致性（Consistency）一致性是指在事务开始之前和事务结束以后，数据库的完整性约束没有被破坏。这是说数据库事务不能破坏关系数据的完整性以及业务逻辑上的一致性。

隔离性（Isolation）多个事务并发访问时，事务之间是隔离的，一个事务不应该影响其它事务运行效果。

持久性（Durability）持久性，意味着在事务完成以后，该事务所对数据库所作的更改便持久的保存在数据库之中，并不会被回滚。

CAP（针对分布式系统）：

Consistency 一致性：在分布式系统中的所有数据备份，在同一时刻具有同样的值，所有节点在同一时刻读取的数据都是最新的数据副本。

Availability 可用性，好的响应性能。完全的可用性指的是在任何故障模型下，服务都会在有限的时间内处理完成并进行响应。

Partition tolerance 分区容忍性。尽管网络上有部分消息丢失，但系统仍然可继续工作。

CAP原理指的是，这三个要素最多只能同时实现两点，不可能三者兼顾。因此在进行分布式架构设计时，必须做出取舍。而对于分布式数据系统，分区容忍性是基本要求，否则就失去了价值。因此设计分布式数据系统，就是在一致性和可用性之间取一个平衡。对于大多数web应用，其实并不需要强一致性，因此牺牲一致性而换取高可用性，是目前多数分布式数据库产品的方向。当然，牺牲一致性，并不是完全不管数据的一致性，否则数据是混乱的。只是不再要求关系型数据库中的强一致性，而是只要系统能达到最终一致性即可。通常是通过数据的多份异步复制来实现系统的高可用和数据的最终一致性的，“用户感知到的一致性”的时间窗口则取决于数据复制到一致状态的时间。

因此大部分的 web 应用，优先考虑 AP，最后考虑C。

BASE

Basically Available（基本可用）：指分布式系统在出现故障的时候，允许损失部分可用性，保证核心可用。但不等价于不可用。

Soft-state（ 软状态/柔性事务）：软状态是指允许系统存在中间状态，并且该中间状态不会影响系统整体可用性。即允许系统在不同节点间副本同步的时候存在延时。

Eventual Consistency（最终一致性）：系统中的所有数据副本经过一定时间后，最终能够达到一致的状态，不需要实时保证系统数据的强一致性。最终一致性是弱一致性的一种特殊情况。

其中，柔性事务满足BASE理论（基本可用，最终一致），刚性事务满足ACID理论。

如何RabbitMQ解决分布式事务问题？

RabbitMQ解决分布式事务原理： 采用最终一致性原理（可短暂的不一致）。需要保证以下三要素：

1、确认生产者一定要将数据投递到MQ服务器中（采用MQ消息确认 Confirm 机制，如果发到 RabbitMQ 服务器发生异常，需要进行重试机制。）

2、MQ消费者消息能够正确消费消息，采用手动ACK模式（注意重试幂等性问题）

3、使用补单机制，即创建一个补单的消息队列，与正常的业务的消息队列绑定在同一台交换机上。补单队列检查数据库是否已经创建，如果未创建则进行数据补偿操作；如果已创建，则删除该消息。

OK，直接上代码。先下载旧，在原来的基础上修改：代码：https://pan.baidu.com/s/15FFaO24xaGAPl0abCQlySQ  提取码：4ejq

代码结构：

bootstrap.yml 配置文件如下：

spring:
  rabbitmq:
    #主机名
    host: 127.0.0.1
    #端口号
    port: 5672
    #账号
    username: guest
    #密码
    password: guest
    #虚拟主机，这里配置的是我们的测试主机
    virtual-host: /test_host

    # 开启消息确认机制 confirms
    publisher-confirms: true
    # 消息在未被队列接收时返回
    publisher-returns: true

    # 修改 RabbitMQ 的重试机制
    listener:
      simple:
        retry:
          # 开启消费者重试机制
          enabled: true
          #最大重试次数
          max-attempts: 5
          # 重试间距（单位：秒）
          initial-interval: 2s
          # 重试最大间隔
          max-interval: 1200s
          # 时间间隔的乘子，下一次间隔的时间=间隔时间 × 乘子，但最大不超过重试最大间隔
          multiplier: 1
          # manual=启手动应答模式，auto=自动应答模式
          acknowledge-mode: manual



# 自定义配置信息
queueConfig:
  # 队列名
  orderQueueName: orderQueueName
  # 交换机名称
  orderExchangeName: orderExchangeName
  # info 路由
  infoRoute: infoRoute


server:
  port: 8080

# 将SpringBoot项目作为单实例部署调试时，不需要注册到注册中心
eureka:
  client:
    fetch-registry: false
    register-with-eureka: false

配置类：

package com.study.config;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.Connection;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;
import java.util.Map;

/**
 * @author biandan
 * @description
 * @signature 让天下没有难写的代码
 * @create 2021-04-05 上午 12:39
 */
@Configuration
public class QueueConfig {

    @Value("${spring.rabbitmq.host}")
    private String host;

    @Value("${spring.rabbitmq.port}")
    private Integer port;

    @Value("${spring.rabbitmq.username}")
    private String username;

    @Value("${spring.rabbitmq.password}")
    private String password;

    @Value("${spring.rabbitmq.virtual-host}")
    private String virtualHost;


    //队列名
    @Value("${queueConfig.orderQueueName}")
    private String orderQueueName;

    //交换机名称
    @Value("${queueConfig.orderExchangeName}")
    private String orderExchangeName;

    //info 路由
    @Value("${queueConfig.infoRoute}")
    private String infoRoute;


    /**
     * 封装连接类
     *
     * @return
     */
    @Bean
    public CachingConnectionFactory connectionFactory() {
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setHost(host);
        connectionFactory.setPort(port);
        connectionFactory.setUsername(username);
        connectionFactory.setPassword(password);
        connectionFactory.setVirtualHost(virtualHost);
        return connectionFactory;
    }


    /**
     * 动态的创建队列（这里仅创建配置文件里的一个）
     *
     * @return
     * @throws Exception
     */
    @Bean
    public String getQueueName() throws Exception {
        //获取连接
        Connection connection = connectionFactory().createConnection();

        //创建通道。true表示有事务功能
        Channel channel = connection.createChannel(true);

        //创建订单队列
        channel.queueDeclare(orderQueueName, true, false, false,null);//创建队列

        //创建订单交换机
        channel.exchangeDeclare(orderExchangeName, BuiltinExchangeType.DIRECT, true, false, null);

        //为订单队列绑定 info 路由
        channel.queueBind(orderQueueName, orderExchangeName, infoRoute);

        //关闭通道
        channel.close();
        //关闭连接
        connection.close();

        return "";
    }
}

订单实体类：

package com.study.entity;

/**
 * @author biandan
 * @description 订单实体类
 * @signature 让天下没有难写的代码
 * @create 2021-04-11 下午 5:32
 */
public class OrderEntity {

    //订单号
    private String orderNo;

    //商品名称
    private String productName;

    public String getOrderNo() {
        return orderNo;
    }

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

    public String getProductName() {
        return productName;
    }

    public void setProductName(String productName) {
        this.productName = productName;
    }
}

消息生产者类：说明，消息模板我们使用 RabbitTemplate，需要实现接口：RabbitTemplate.ConfirmCallback

package com.study.producer;

import com.alibaba.fastjson.JSONObject;
import com.study.entity.OrderEntity;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageBuilder;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.support.CorrelationData;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Random;
import java.util.UUID;

/**
 * @author biandan
 * @description 消息生产者（扇形交换机）
 * @signature 让天下没有难写的代码
 * @create 2021-04-04 下午 10:49
 */
@Component
public class DirectProducer implements RabbitTemplate.ConfirmCallback {

    private SimpleDateFormat SDF = new SimpleDateFormat("yyyyMMddHHmmss");

    //交换机名称
    @Value("${queueConfig.orderExchangeName}")
    private String orderExchangeName;

    //info 路由
    @Value("${queueConfig.infoRoute}")
    private String infoRoute;


    /**
     * 注入 Rabbit 消息模板
     */
    @Autowired
    private RabbitTemplate template;

    /**
     * 每隔1分钟产生一条消息
     */
    @Scheduled(fixedRate = 1000 * 60)
    public void orders() {
        //模拟用户下单
        OrderEntity orderEntity = new OrderEntity();
        String orderNo = SDF.format(new Date()) + System.currentTimeMillis();
        orderEntity.setOrderNo(orderNo);//订单号
        orderEntity.setProductName("霸王防脱洗发液");//商品名称
        System.out.println("顾客下单信息已保存到数据库，订单号为：" + orderNo);

        sendToRabbitMQ(orderNo);

    }

    /**
     * 发送到 RabbitMQ 服务器
     *
     * @param orderNo
     */
    private void sendToRabbitMQ(String orderNo) {
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("orderNo", orderNo);
        String msg = jsonObject.toJSONString();

        Message message = MessageBuilder.withBody(msg.getBytes())
                .setContentType(MessageProperties.CONTENT_TYPE_JSON) //json格式
                .setContentEncoding("utf-8") //utf-8编码方式
                .setMessageId(UUID.randomUUID() + "")//使用 UUID 作为消息ID，UUID保证全局唯一
                .build();

        // 构建回调返回的数据（消息id）
        template.setMandatory(true);
        template.setConfirmCallback(this);

        CorrelationData correlationData = new CorrelationData(orderNo);

        //发送消息（往路由发消息，而不是往队列发消息）
        template.convertAndSend(orderExchangeName, infoRoute, message, correlationData);
    }

    /**
     * 生产消息确认机制：生产者往服务器端发送消息的时候，采用应答机制
     *
     * @param correlationData
     * @param ack             是否以确认
     * @param cause           原因
     */
    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {
        String orderNo = correlationData.getId();
        System.out.println("确认机制返回的订单号：" + correlationData.getId());
        if (ack) {
            System.out.println("消息发送确认成功");
        } else {
            // 重试机制
            sendToRabbitMQ(orderNo);
            System.out.println("消息发送确认失败：" + cause);
        }

    }
}

启动类：

package com.study;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication
@EnableScheduling //启用任务调度
@EnableEurekaClient
public class RabbitMQOrderApplication {
    public static void main(String[] args) {
        SpringApplication.run(RabbitMQOrderApplication.class, args);
    }
}

OK，我们先启动服务：理论上会回调 confirm 函数，但是本人尝试了2天来解决这个问题，都没法让它回调 confirm 函数，应该是版本问题，所以决定放弃了。浪费我太多时间！如果有伙计能让程序回调此函数，不妨评论区说一下解决办法！

OK，我们知道消息生产者使用 confirm 机制能保证消息可以发送到 RabbitMQ 服务器即可！

现在我们思考一个场景：如果消息生产者已经将消息发给 RabbitMQ 服务器了，消费者也正常消费了，这时候消息生产者出现异常，导致事务回滚：比如以下代码：

思考：用户已经收到下单成功的通知，但是事务回滚导致商家并没有在后台看到此订单！这个问题怎么解决？

解决思路：这是分布式系统经常要面对的问题之一。我们可以考虑增加一个补单队列，与订单队列绑定在相同的交换机上。交换机将订单消息同时发送给这两个队列，其中补单队列绑定补单消费者。补单消费者获取到补单队列的订单消息后，查询数据库里有没有该订单的信息，如果有，则告诉补单队列的 RabbitMQ 服务器进行删除该消息。如果没有该订单数据，则创建。

OK，我们创建一个补单队列。bootstrap.yml 配置如下：

spring:
  rabbitmq:
    #主机名
    host: 127.0.0.1
    #端口号
    port: 5672
    #账号
    username: guest
    #密码
    password: guest
    #虚拟主机，这里配置的是我们的测试主机
    virtual-host: /test_host

    # 开启消息确认机制 confirms
    publisher-confirms: true
    # 消息在未被队列接收时返回
    publisher-returns: true


# 自定义配置信息
queueConfig:
  # 队列名
  orderQueueName: orderQueueName
  # 交换机名称
  orderExchangeName: orderExchangeName
  # info 路由
  infoRoute: infoRoute

  # 队列名-补单队列
  backOrderQueueName: backOrderQueueName
  # info 路由-补单路由
  backInfoRoute: backInfoRoute

server:
  port: 8080

# 将SpringBoot项目作为单实例部署调试时，不需要注册到注册中心
eureka:
  client:
    fetch-registry: false
    register-with-eureka: false

配置文件：QueueConfig，主要是创建补单队列，绑定交换机。

package com.study.config;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.Connection;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;
import java.util.Map;

/**
 * @author biandan
 * @description
 * @signature 让天下没有难写的代码
 * @create 2021-04-05 上午 12:39
 */
@Configuration
public class QueueConfig {

    @Value("${spring.rabbitmq.host}")
    private String host;

    @Value("${spring.rabbitmq.port}")
    private Integer port;

    @Value("${spring.rabbitmq.username}")
    private String username;

    @Value("${spring.rabbitmq.password}")
    private String password;

    @Value("${spring.rabbitmq.virtual-host}")
    private String virtualHost;


    //队列名
    @Value("${queueConfig.orderQueueName}")
    private String orderQueueName;

    //交换机名称
    @Value("${queueConfig.orderExchangeName}")
    private String orderExchangeName;

    //info 路由
    @Value("${queueConfig.infoRoute}")
    private String infoRoute;


    //补单队列名
    @Value("${queueConfig.backOrderQueueName}")
    private String backOrderQueueName;

    //补单info 路由
    @Value("${queueConfig.backInfoRoute}")
    private String backInfoRoute;

    /**
     * 封装连接类
     *
     * @return
     */
    @Bean
    public CachingConnectionFactory connectionFactory() {
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setHost(host);
        connectionFactory.setPort(port);
        connectionFactory.setUsername(username);
        connectionFactory.setPassword(password);
        connectionFactory.setVirtualHost(virtualHost);
        return connectionFactory;
    }


    /**
     * 动态的创建队列（这里仅创建配置文件里的一个）
     *
     * @return
     * @throws Exception
     */
    @Bean
    public String getQueueName() throws Exception {
        //获取连接
        Connection connection = connectionFactory().createConnection();

        //创建通道。true表示有事务功能
        Channel channel = connection.createChannel(true);

        //创建订单队列
        channel.queueDeclare(orderQueueName, true, false, false,null);//创建队列

        //创建订单交换机
        channel.exchangeDeclare(orderExchangeName, BuiltinExchangeType.DIRECT, true, false, null);

        //为订单队列绑定 info 路由
        channel.queueBind(orderQueueName, orderExchangeName, infoRoute);

        //创建补单队列
        channel.queueDeclare(backOrderQueueName, true, false, false,null);
        
        //为补单队列绑定info路由
        channel.queueBind(backOrderQueueName,orderExchangeName,backInfoRoute);
        
        //关闭通道
        channel.close();
        //关闭连接
        connection.close();

        return "";
    }
}

消息生产者：

package com.study.producer;

import com.alibaba.fastjson.JSONObject;
import com.study.entity.OrderEntity;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageBuilder;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.support.CorrelationData;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import java.text.SimpleDateFormat;
import java.util.*;

/**
 * @author biandan
 * @description 消息生产者（扇形交换机）
 * @signature 让天下没有难写的代码
 * @create 2021-04-04 下午 10:49
 */
@Component
public class DirectProducer implements RabbitTemplate.ConfirmCallback {

    private SimpleDateFormat SDF = new SimpleDateFormat("yyyyMMddHHmmss");

    public static List<OrderEntity> orderEntityList = new ArrayList<>();

    //交换机名称
    @Value("${queueConfig.orderExchangeName}")
    private String orderExchangeName;

    //info 路由
    @Value("${queueConfig.infoRoute}")
    private String infoRoute;

    //补单info 路由
    @Value("${queueConfig.backInfoRoute}")
    private String backInfoRoute;
    
    /**
     * 注入 Rabbit 消息模板
     */
    @Autowired
    private RabbitTemplate template;

    /**
     * 每隔1分钟产生一条消息
     */
    @Scheduled(fixedRate = 1000 * 60)
    public void orders() {
        //模拟用户下单
        OrderEntity orderEntity = new OrderEntity();
        String orderNo = SDF.format(new Date()) + System.currentTimeMillis();
        orderEntity.setOrderNo(orderNo);//订单号
        orderEntity.setProductName("霸王防脱洗发液");//商品名称
        System.out.println("顾客下单信息保存到数据库，订单号为：" + orderNo);

        sendToRabbitMQ(orderNo);

        //模拟程序异常，导致数据回滚，没有存入数据库（或者缓存、内存）
        int k = 9 /0 ;
        //模拟将订单数据存入数据库（或者缓存、内存）
        orderEntityList.add(orderEntity);

    }


    /**
     * 发送到 RabbitMQ 服务器
     *
     * @param orderNo
     */
    private void sendToRabbitMQ(String orderNo) {
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("orderNo", orderNo);
        String msg = jsonObject.toJSONString();

        Message message = MessageBuilder.withBody(msg.getBytes())
                .setContentType(MessageProperties.CONTENT_TYPE_JSON) //json格式
                .setContentEncoding("utf-8") //utf-8编码方式
                .setMessageId(orderNo)//使用订单号做消息ID
                .build();

        // 构建回调返回的数据（消息id）
        template.setMandatory(true);
        template.setConfirmCallback(this);

        CorrelationData correlationData = new CorrelationData(orderNo);

        //发送消息（往路由发消息，而不是往队列发消息）
        template.convertAndSend(orderExchangeName, infoRoute, message, correlationData);
        template.convertAndSend(orderExchangeName, backInfoRoute, message, correlationData);
    }

    /**
     * 生产消息确认机制：生产者往服务器端发送消息的时候，采用应答机制
     *
     * @param correlationData
     * @param ack             是否以确认
     * @param cause           原因
     */
    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {
        String orderNo = correlationData.getId();
        System.out.println("确认机制返回的订单号：" + correlationData.getId());
        if (ack) {
            System.out.println("消息发送确认成功");
        } else {
            // 重试机制
            sendToRabbitMQ(orderNo);
            System.out.println("消息发送确认失败：" + cause);
        }

    }
}

消费者：Consumer_Order

package com.study.consumer;

import com.alibaba.fastjson.JSONObject;
import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.support.AmqpHeaders;
import org.springframework.messaging.handler.annotation.Headers;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.Map;

/**
 * @author biandan
 * @description 消费者
 * @signature 让天下没有难写的代码
 * @create 2021-04-04 下午 11:39
 */
@Component
public class Consumer_Order {

    //订单队列的消费者
    @RabbitListener(queues = "${queueConfig.orderQueueName}")//需要把 @RabbitListener 标注到方法上
    public void receiveMsg(Message message, @Headers Map<String, Object> headers, Channel channel) throws Exception{
        String messageId = message.getMessageProperties().getMessageId();
        System.out.println(new Date() + " 消费者获取到的订单号 orderNo=" + messageId);
        try {
            String msg = new String(message.getBody(), "utf-8");
            JSONObject jsonObject = JSONObject.parseObject(msg);
            String orderNo = jsonObject.getString("orderNo");
            System.out.println("下单成功，您的订单号是："+orderNo);

            //手动ack应答
            Long deliveryTag = (Long) headers.get(AmqpHeaders.DELIVERY_TAG);
            //手动签收
            channel.basicAck(deliveryTag, false);
        } catch (Exception e) {
            e.printStackTrace();
            //丢弃该消息
            channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, false);
        }
    }

}

补单消费者：Consumer_BackOrder

package com.study.consumer;

import com.alibaba.fastjson.JSONObject;
import com.rabbitmq.client.Channel;
import com.study.entity.OrderEntity;
import com.study.producer.DirectProducer;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.support.AmqpHeaders;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.messaging.handler.annotation.Headers;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.Map;

/**
 * @author biandan
 * @description 消费者
 * @signature 让天下没有难写的代码
 * @create 2021-04-04 下午 11:39
 */
@Component
public class Consumer_BackOrder {

    //补单队列的消费者
    @RabbitListener(queues = "${queueConfig.backOrderQueueName}")//需要把 @RabbitListener 标注到方法上
    public void receiveMsg(Message message, @Headers Map<String, Object> headers, Channel channel) throws Exception {
        String orderNo = message.getMessageProperties().getMessageId();
        System.out.println(new Date() + " 补单消费者获取到的消息 orderNo=" + orderNo);
        try {
            boolean flag = false;
            //查询数据库（或者缓存、内存）
            for (OrderEntity orderEntity : DirectProducer.orderEntityList) {
                String existOrderNo = orderEntity.getOrderNo();
                if (existOrderNo.equals(orderNo)) {//如果已经存在该订单，通知补单队列进行删除
                    flag = true;
                    System.out.println("已经存在该订单啦");
                }
            }

            if (!flag) {//如果没有存在该订单，则将订单数据存入到数据库（或者缓存、内存）中
                OrderEntity orderEntity = new OrderEntity();
                orderEntity.setOrderNo(orderNo);
                //这个产品先固定
                orderEntity.setProductName("霸王防脱洗发液");
                System.out.println("订单数据不存在，已重新生成：" + JSONObject.toJSONString(orderEntity));
                DirectProducer.orderEntityList.add(orderEntity);
            }

            //手动ack应答
            Long deliveryTag = (Long) headers.get(AmqpHeaders.DELIVERY_TAG);
            //手动签收
            channel.basicAck(deliveryTag, false);

        } catch (Exception e) {
            e.printStackTrace();
            //丢弃该消息
            channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, false);
        }
    }

}

OK，启动项目，在2个消费者方法里打上断点：

消息生产者生产消息后，查看 RabbitMQ 后台：两个队列都收到了消息。（其实可以使用扇形交换机 fanout，会自动把消息推送到所有绑定到交换机的队列上。这里演示效果，用直连交换机。）

然后查看控制台输出：订单数据已经发送给 RabbitMQ ，但是程序抛出了异常，导致数据回滚。这时候补单队列判断数据库里没有该订单，重新补单写入到数据库了。

OK，现在把生产者的报错信息去掉，再重试一次：

重启服务，控制台输出： 

思考：如果补单队列仍然报错，就需要记录日志，进行人工补偿了。

完整代码：https://pan.baidu.com/s/1CJ7WPQXsaDZK5R_yag83vA 提取码：uuwt

流放深圳
关注
  • 1
    点赞
  • 踩
  • 37
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
rabbitmq解决分布式事务
01-28
消费者在消费消息的时候，如果消费者业务逻辑出现程序异常，这时候应该如何处理？ 答案：使用消息重试机制。(springboot默认有消息重试机制) 消费者获取到消息后，调用第三方接口，但接口暂时无法访问，是否需要重试?（需要重试机制） 消费者获取到消息后，抛出数据转换异常，是否需要重试?（不需要重试机制）需要发布进行解决。
rabbitmq分布式事务
12-01
基于rabbit和本地消息表实现可靠消息一致性分布式事务，项目下载下来直接可以用了，已经包含了配置文件和数据库脚本，有问题的可以给我私信。项目架构springboot、nacos、rabbitMq、redis、MySQL
Rabbitmq实现多系统间的分布式事务，保证数据一致性
STIll_ly的博客
01-30 2962
Rabbitmq实现多系统间的分布式事务，保证数据一致性一、实验环境二、实验目的三、实验方案四、实验步骤1、消息队列2、数据库准备2.1订单表2.2 消息发送状态表2.3 运单表3、订单中心3.1 订单中心分析3.2 编写代码3.2.1 Springboot整合rabbitmq和mysql数据库3.2.1.1依赖如下：3.2.1.2配置文件内容：3.2.2 订单中心代码3.3 订单中心测试3.3....
如何用 RabbitMQ 解决分布式事务？
Java5658的博客
06-14 1163
要说哪种分布式事务处理方案效率高，必然绕不开消息中间件！基于消息中间件的两阶段提交方案，通常用在高并发场景下。这种方式通过牺牲数据的强一致性换取性能的大幅提升，不过实现这种方式的成本和复杂度是比较高的，使用时还要看实际业务情况。...
RabbitMQ——解决分布式事务问题，RabbitMQ的重要作用之一！！！通过可靠生产和可靠消费来完美解决！
最新发布
不积跬步无以至千里
12-14 987
分布式事务是指涉及多个独立的计算机系统（也称为节点或参与者）之间的事务处理。在分布式系统中，每个节点可能各自拥有自己的数据存储和事务管理机制。分布式事务的目标是保证在跨多个节点执行的一系列操作可以以一致和可靠的方式执行和提交，即使在面对故障或并发操作时也能保持数据的完整性和一致性。实现分布式事务可以采用两阶段提交（Two-Phase Commit）协议或三阶段提交（Three-Phase Commit）协议等机制。这些协议通过协调参与者之间的状态和决策来实现分布式事务的一致性。
通过RabbitMQ实现分布式事务
weixin_42351206的博客
09-13 5001
通过RabitMQ实现分布式事务题前言业务需求核心原理核心难点解决问题思路代码实现其他总结 前言 这篇文章是通过学习哔哩哔哩中的视频“阿里架构师如何30分钟基于MQ解决分布式事务问题”，原视频连接https://www.bilibili.com/video/BV15p4y1D7d7?p=2 业务需求 这是一次简单的模拟分布式事务的：假设我们现在需要支付宝向余额宝转账100元。支付宝(系统A)向余额宝(系统B)转账100元，支付宝余额-100，余额宝余额加100。这涉及到两个系统，需要用到分布式事务。 核心原
RabbitMQ实现分布式事务
王小白来了
09-27 1766
前言
RabbitMQ高级 -- 分布式事务
weixin_46724181的博客
04-12 3587
一、引言 前端时间因为忙着学吉他~ 就耽误正事了~ 现在就赶紧补回来~~ 二、目录
基于RabbitMQ解决分布式事务
Tiger_Paul的博客
03-03 2424
1、可查询操作：服务操作具有全局唯一的标识，操作唯一的确定的时间。 2、幂等操作：重复调用多次产生的业务结果与调用一次产生的结果相同。一是通过业务操作实现幂等性，二是系统缓存所有请求与处理的结果，最后是检测到重复请求之后，自动返回之前的处理结果。 3、TCC操作：Try阶段，尝试执行业务，完成所有业务的检查，实现一致性；预留必须的业务资源，实现准隔离性。Confirm阶段：真正的去执行业务，不做任何检查，仅适用Try阶段预留的业务资源，Confirm操作还要满足幂等性。Cancel阶段：取消执行业务，释放T
RabbitMQ高级——分布式事务
Java是世界上最好的语言
10-12 847
简述 分布式事务指事务的操作位于不同的节点上，需要保证事务的ACID特性。 例如在下单场景下，库存和订单如果不在同一个节点上就会设计到分布式事务处理。 案例 我们可以手动模拟一个下单操作，用户下单之后开始派送。通过以下工程演示分布式事务问题。 当我们创建完两个项目之后，可以先将派送工程中的模拟错误去除，然后运行派送工程。 在订单服务中创建测试类，当程序运行之后，我们可以发现两个数据库中都会新增相应的数据，这就代表我们的流程走通了。 但是当我们在派送工程中模拟错误，使订单服务调用派送服务失败的时候，我们可以
springboot整合stream使用rabbitmq作为消息中间件
12-13
springboot整合stream使用rabbitmq作为消息中间件
基于RabbitMQ消息队列的分布式事务解决方案
02-24
介绍Rabbitmg用于解决分布式事务必须掌握的5个核心概念一款分布式消息中间件，基于erlang语言开发，具备语言级别的高并发处理能力。和Spring框架是同一家公司。支持持久化、高可用1.Queue:真正存储数据的地方2....
SpringBoot整合RabbitMQ
K_kzj_K的博客
06-09 4313
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。 以上..
RabbitMQ实现分布式的事务处理（基础向）
Deroser的博客
08-22 729
RabbitMQ实现分布式的事务处理 由于分布式微服务架构是由consumer将请求发到provider去处理mapper的业务，所以无法使用@Transactional注解，这里需要使用消息中间件，也就是RabbitMQ 事务概念：将一个逻辑单元中涉及到的所有数据库实例的操作捆绑成为一个整体进行管理 RabbitMQ概念：主流的消息队列之一,它遵循AMQP协议,由内在高并发的 Erlang语言开发,用在实时的对可靠性要求比较高的消息传递上 ​ 生产者 Producer：发送消息 ​ 消费者 Consume
mq消息队列解决分布式事务
高飞
03-31 1024
一、RabbitMQ解决分布式事务思路： 案例： 经典案例，以目前流行点外卖的案例，用户下单后，调用订单服务，让后订单服务调用派单系统通知送外卖人员送单，这时候订单系统与派单系统采用MQ异步通讯。 二、RabbitMQ解决分布式事务原理：采用最终一致性原理。 需要保证以下三要素 1、确认生产者一定要将数据投递到MQ服务器中（采用MQ消息确认机制） 2、MQ消费者消息能够正确消费消息，采用...
分布式事务
m0_67463445的博客
05-04 1799
本地消息表的最终一致方案采用BASE原理，保证事务最终一致。在一致性方面，允许一段时间内的不一致，但最终会一致。本地消息表实现分布式事务应该是网站前台使用最多的，其核心思想是将分布式事务拆分成本地事务进行处理，这种思路是来源于ebay。使用本地消息表，消息生产方，需要额外建一个消息表，并记录消息发送状态。消息表和业务数据要在一个事务里提交，也就是说他们要在一个数据库里面。然后消息会经过MQ发送到消息的消费方。如果消息发送失败，会进行重试发送。消息消费方，需要处理这个消息，并完成自己的业务逻辑。
springboot + rabbitmq 实现分布式事务（可靠性生产者）
qq_53167164的博客
06-29 823
分布式事务（可靠性生产者） 实现思路：采取消息冗余+定时器 实际上就是保证消息的成功投递 例子：订单（生产者）+派送（消费者） springboot+rabbitmq在Windows环境下实现 pom: <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifa
微服务架构-分布式消息中间件-086：RabbitMQ解决分布式事务问题
枫火的博客
03-01 569
086：RabbitMQ解决分布式事务问题1 RPC分布式事务产生的背景2 如何理解分布式事务最终一致性3 基于RabbitMQ解决分布式事务思路4 代码实现基于RabbitMQ解决分布式事务15 代码实现基于RabbitMQ解决分布式事务26 分布式事务补单队列的实现 1 RPC分布式事务产生的背景 课程内容: 30分钟未支付，系统自动超时关闭订单实现方案 消息中间件自动补偿触发原理 消息中间件如何合理选择重试机制 消息中间件如何解决消费者幂等性 SpringBoot整合消息确认机制 业务场景：使用公
SpringBoot整合消息中间件 RabbitMQ 第 8 篇 —— 补偿机制（重试机制）、解决幂等性问题、手动确认消息
流放深圳
04-11 1490
补偿机制（重试机制） RabbitMQ 队列服务器，对消息默认有个补偿机制。即当消费者没有成功消费消息时，会缓存消息，并且不断的把消息重新发给消费者，直到消息被消费掉（默认情况下会一直发，除非我们修改配置）。RabbitMQ 底层是使用 Spring AOP 进行拦截，如果消费者的@RabbitListener 函数报错，会自动触发重试机制。 我们来演示一下。我们使用之前的项目进行测试。代码在百度网盘连接：https://pan.baidu.com/s/1Izb0WbsuLCJJXlm445...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值