RabbitMQ（十一）【高级 - 分布式事务】

已于 2023-02-28 09:51:23 修改
阅读量735 收藏 3
点赞数
分类专栏： RabbitMQ 文章标签： java-rabbitmq rabbitmq 分布式
于 2022-08-29 00:29:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Wei_Naijia/article/details/126576441
版权

十一、RabbitMQ - 高级 - 分布式事务

上一篇文章《高级 - 集群》

简述

分布式事务指事务操作位于不同的节点上，需要保证事物的ACID特性

例如再下单场景下，库存和订单如果不在同一节点上，就涉及分布式事务

11.1 分布式事务的方式

在分布式系统中，要实现分布式事务，无外乎那几种解决方案

两阶段提交（2PC）需要数据库厂商的支持，java组件有atomikos等

两阶段提交（Two-phase Commit，2PC），通过引入协调者（Coordinator）来协调参与者的行为，并最终决定这些参与者是否要真正执行事务

1. 准备阶段

协调者询问参与者事务是否执行成功，参与者发回事务执行结果

在这里插入图片描述

2. 提交阶段

如果事务在每个参与者上都执行成功，事务协调者发送通知让参与者提交事务；否则，协调者发送通知让参与者回滚事务

需要注意的是，在准备阶段，参与者执行了事务，但还未提交。只有在提交阶段接收到协调者发来的通知之后，才进行提交或回滚

在这里插入图片描述

存在问题

  • 同步阻塞：所有事务参与者在等待其它参与者响应的时候都处于同步阻塞状态，无法进行其它操作
  • 单点问题：协调者在 2PC 中起到非常大的作用，发生故障会造成很大影响。特别是在阶段二发生故障，所有参与者会一直处于等待状态，无法完成其它操作
  • 数据不一致：在阶段二，如果协调者只发送了部分commit消息，此时网络发生异常，那么只有部分参与者接收到commit消息，也就是说只有部分参与者提交了事务，使得系统数据不一致
  • 太过于保守：任意一个节点失败就会导致整个事务失败，没用完善的容错机制

补偿事务（TCC）严选，阿里，蚂蚁金服

TCC 其实就是采用补偿机制，其核心思想是：针对每个操作，都要注册一个与其对应的确认和补偿（撤销）操作。它分为三个阶段

  • Try：阶段主要是对业务系统做检测及资源预留
  • Confirm：阶段主要是对业务系统做确认提交，Try 阶段执行成功并开始执行 Confirm 阶段时，默认 Confirm 阶段是不会出错的。即：只要 Try 成功，Confirm 一定成功
  • Cancel：阶段主要是在业务执行异常时，需要回滚的状态下执行业务取消，预留资源释放

本地消息表（异步确保）比如：支付宝、微信支付主动查询支付状态，对账单的形式

本地消息表对业务数据表处于同一个数据库中，这样就能利用本地事务来保证在对这两个表的操作满足事务特性，并且使用了消息队列来保证最终一致性

  • 在分布式事务操作的一方完成写业务数据的操作之后向本地消息表发送一个消息，本地事务能保证这个消息一定会被写入本地消息表中
  • 之后将本地消息表中的消息转发到 Kafka 等消息队列中，如果转发成功则将消息从本地消息表中删除，否则继续重新转发
  • 在分布式事务操作的另一方，从消息队列中读取一个消息，并执行消息中的操作

在这里插入图片描述

优点：一种非常经典的实现，避免了分布式事务，实现了最终一致性

缺点：消息表会耦合到业务系统中，如果没用封装好的解决方案，会有很多杂务需要处理

MQ 事务消息 异步场景，通用性较强，拓展性较高

有一些第三方的MQ是支持事务消息的，比如 RocketMQ，它们支持事务消息的方式也是类似于采用二阶段提交，但是市面上一些主流MQ都是不支持事务消息的，比如 Kafka 不支持

以及阿里的 RabbitMQ 中间件为例，其思路大致为

  • 第一阶段 Prepared 消息，会拿到消息的地址。第二阶段执行本地事务，第三阶段通过第一阶段拿到的地址去访问消息，并修改状态
  • 在业务方法内要想消息队列提交两次请求，一次发送消息和一次确认消息，如果确认消息发送失败了，RabbitMQ 会定期扫描消息集群中的事务消息，这时候发现了 Prepared 消息，它会向消息发送者确认，所以生产方需要需要实现一个 ckeck 接口，RabbitMQ 会根据发送端设置的策略来决定是回滚还是继续发送确认消息。这样就保证了消息发送与本地事务同时成功或同时失败

在这里插入图片描述

优点：实现了最终一致性，不需要以来本地数据库事务

缺点：实现难度大，主流MQ不支持，RockerMQ 事务消息部分代码为开源

11.2 RabbitMQ - 高级 - 分布式案例

在这里插入图片描述

场景测试

  1. 建数据库rabbitmq_dispatch和rabbitmq_order
# 数据库 rabbitmq_dispatch
CREATE DATABASE `rabbitmq_dispatch` /*!40100 DEFAULT CHARACTER SET utf8 */
# 数据库 rabbitmq_order
CREATE DATABASE `rabbitmq_order` /*!40100 DEFAULT CHARACTER SET utf8 */

# 在数据库 rabbitmq_dispatch 中创建表order
CREATE TABLE `order` (
  `dispatch_id` varchar(100) DEFAULT NULL,
  `order_id` int(11) DEFAULT NULL,
  `status` varchar(20) DEFAULT NULL,
  `order_content` varchar(100) DEFAULT NULL,
  `create_time` date DEFAULT NULL,
  `user_id` int(11) DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8

# 在数据库 rabbitmq_order 中创建表order
CREATE TABLE `order` (
  `order_id` int(11) DEFAULT NULL,
  `user_id` int(11) DEFAULT NULL,
  `order_content` varchar(100) DEFAULT NULL,
  `create_time` date DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8
  1. 创建一个springboot工程rabbitmq-dispatcher-service

1）导入依赖

<dependencies>
    <!--Rabbitmq-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-amqp</artifactId>
    </dependency>

    <!--JDBC-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>
    <!--web-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!--lombok-->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>

    <!--热部署工具-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>
    <!--MySQL连接驱动-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.47</version>
    </dependency>

    <!--json数据格式转换-->
    <dependency>
        <groupId>com.fasterxml.jackson.dataformat</groupId>
        <artifactId>jackson-dataformat-avro</artifactId>
    </dependency>
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-lang3</artifactId>
        <version>3.10</version>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
        <exclusions>
            <exclusion>
                <groupId>org.junit.vintage</groupId>
                <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>org.springframework.amqp</groupId>
        <artifactId>spring-rabbit-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

2）application.yml配置文件

server:
  port: 9000

spring:
  # 服务应用名称
  application:
    name: rabbitmq_dispatch
  # 配置数据源
  datasource:
    url: jdbc:mysql://localhost:3306/rabbitmq_dispatch?useSSL=false&useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
    username: root
    password: 123456
    driver-class-name: com.mysql.jdbc.Driver
  rabbitmq:
#    单机
#    port: 5673
#    host: 192.168.159.100
    # 集群部署
    addresses: 192.168.159.100:5673,192.168.159.100:5674,192.168.159.100:5675
    username: admin
    password: admin
    virtual-host: /
    # 手动开启ack,让程序去控制MQ的消息和重发、删除、转移
    listener:
      simple:
        acknowledge-mode: manual
        retry:
          # 开启重试模式
          enabled: true
          # 最大重试数
          max-attempts: 10

3）service包下的DispatchService.java类

package com.vinjcent.rabbitmq.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;


import java.util.UUID;

@SuppressWarnings("all")
@Service
@Transactional(rollbackFor = Exception.class)
public class DispatchService {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    // 运单接收
    public void dispatch(Integer orderId) throws Exception {
        // 定义保存sql
        String sql = "insert into rabbitmq_dispatch.order(order_id,dispatch_id,status,order_content,user_id) values (?,?,?,?,?)";
        // 添加运动记录
        int count = jdbcTemplate.update(sql, orderId, UUID.randomUUID().toString(), "0","今晚吃鸡!",1);

        if (count != 1){
            throw new Exception("订单创建失败,原因[数据库操作失败]");
        }
    }

}

4）controller包下的DispatchController.java类

package com.vinjcent.rabbitmq.controller;

import com.vinjcent.rabbitmq.service.DispatchService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SuppressWarnings("all")
@RestController
@RequestMapping("/dispatch")
public class DispatchController {

    @Autowired
    DispatchService dispatchService;

    // 添加订单后,添加调度信息
    @GetMapping("/order")
    public String lock(Integer orderId) throws Exception {
        if (orderId == 15){
            System.out.println("1111");
            Thread.sleep(3000L);    // 模拟业务耗时,接口调用者会认为超时
        }
        dispatchService.dispatch(orderId);  // 分配运单
        return "success";
    }

}
  1. 创建一个springboot工程rabbitmq-order-service

1）导入依赖

<dependencies>
    <!--Rabbitmq-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-amqp</artifactId>
    </dependency>

    <!--JDBC-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!--lombok-->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>

    <!--热部署-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>
    <!--MySQL连接驱动-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.47</version>
    </dependency>

    <!--json数据格式转换-->
    <dependency>
        <groupId>com.fasterxml.jackson.dataformat</groupId>
        <artifactId>jackson-dataformat-avro</artifactId>
    </dependency>
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-lang3</artifactId>
        <version>3.10</version>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
        <exclusions>
            <exclusion>
                <groupId>org.junit.vintage</groupId>
                <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>org.springframework.amqp</groupId>
        <artifactId>spring-rabbit-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

2）application.yml配置文件

server:
  port: 8000

spring:
  # 服务应用名称
  application:
    name: rabbitmq_order
  # 配置数据源
  datasource:
    url: jdbc:mysql://localhost:3306/rabbitmq_order?useSSL=false&useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
    username: root
    password: 123456
    driver-class-name: com.mysql.jdbc.Driver
  rabbitmq:
    #    单机
    #    port: 5673
    #    host: 192.168.159.100
    # 集群部署
    addresses: 192.168.159.100:5673,192.168.159.100:5674,192.168.159.100:5675
    username: admin
    password: admin
    virtual-host: /
    # 手动开启ack,让程序去控制MQ的消息和重发、删除、转移
    listener:
      simple:
        acknowledge-mode: manual
        retry:
          # 开启重试模式
          enabled: true
          # 最大重试数
          max-attempts: 10

3）实体类Order.java

package com.vinjcent.rabbitmq.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;
import java.util.Date;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Order implements Serializable {

    private Integer orderId;
    private Integer userId;
    private String orderContent;
    private Date createTime;
}

4）service包下的类

OrderDatabaseService.java

package com.vinjcent.rabbitmq.service;

import com.vinjcent.rabbitmq.pojo.Order;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@SuppressWarnings("all")
@Service
@Transactional(rollbackFor = Exception.class)
public class OrderDatabaseService {

    @Autowired
    private JdbcTemplate jdbcTemplate;


    /*
     * 保存订单记录
     */
    public void saveOrder(Order order) throws Exception {
        // 定义保存sql
        String sql = "insert into rabbitmq_order.order(order_id,user_id,order_content) values(?,?,?)";

        // 添加记录
        int count = jdbcTemplate.update(sql, order.getOrderId(), order.getUserId(), order.getOrderContent());

        if (count != 1){
            throw new Exception("订单创建失败,原因[数据库操作失败]");
        }

        // 因为下单可能会使rabbitmq服务器出现宕机,从而引发消息没用放入MQ,为了消息可靠生产,对消息做一次冗余
        //saveLocalMessage(order);
    }

    /*
     * 保存信息到本地
     */
    public void saveLocalMessage(Order order) {
        // 定义sql
        String sql = "insert into message(order_id,order_content,status,unique id) values (?,?,?,?)";
    }


}

OrderService.java

package com.vinjcent.rabbitmq.service;

import com.vinjcent.rabbitmq.pojo.Order;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.client.RestTemplate;

@SuppressWarnings("all")
@Service
public class OrderService {

    @Autowired
    private OrderDatabaseService orderDatabaseService;

    @Transactional(rollbackFor = Exception.class)
    public void createOrder(Order order) throws Exception {

        // 1.创建订单
        orderDatabaseService.saveOrder(order);

        // 2.通过http接口发送订单信息到运单系统
        String result = dispatchHttpApi(order.getOrderId());
        if (!"success".equals(result)){
            throw new Exception("订单创建失败,原因是运单接口调用失败!");
        }

    }

    public String dispatchHttpApi(Integer orderId) {
        SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
        // 连接超时 > 3s
        factory.setConnectTimeout(3000);
        // 处理超时 > 2s
        factory.setReadTimeout(2000);
        // 发送http请求
        String url = "http://localhost:9000/dispatch/order?orderId="+orderId;
        RestTemplate restTemplate = new RestTemplate(factory);
        String result = restTemplate.getForObject(url, String.class);
        return result;
    }

}
  1. 启动工程rabbitmq-dispatcher-service
  2. 运行工程rabbitmq-order-service测试类下的函数
@SpringBootTest
class RabbitmqOrderServiceApplicationTests {

    @Autowired
    OrderService orderService;

    @Test
    void contextLoads() {
    }

    @Test
    void testCreateOrder() throws Exception {
        Order order = new Order(15,1,"今晚吃鸡!",new Date());
        orderService.createOrder(order);
        System.out.println("订单创建成功......");
    }
}
  1. 观察rabbitmq-order-service工程的控制台

在这里插入图片描述

分析：

在rabbitmq-order-service工程下，运行测试创建订单时，设置了分布式请求，添加调度信息调用另外一个微服务的接口；在rabbitmq-dispatcher-service工程下的/dispatch/order接口设置睡眠时间模拟用户读取超时，从而造成创建订单超时的异常（在rabbitmq-order-service工程下抛出）

如果没有设置全局事务（如@GlobalTransactional），不同微服务中的事务并不会直接干涉到。在OrderService.java类中，给createOrder()函数声明了事务的回滚，同样在http请求另外一个微服务接口的过程中同样也声明了事务回滚，但是在rabbitmq-order-service工程下出现了异常，也即是说在创建订单时出现了异常，回滚了订单，但是在rabbitmq-dispatcher-service工程下的转发过程并没有异常的抛出，所以数据不会回滚

为解决该类问题，使用RabbitMQ来解决

11.3 RabbitMQ - 高级 - 可靠生产和消息推送

基于MQ的分布式事务整体设计思路

在这里插入图片描述

分布式系统分布式事务问题 - 可靠生产问题

在这里插入图片描述

可靠生产和可靠消费的示意图

在这里插入图片描述

测试用例

在rabbitmq-order-service工程

  1. 在rabbitmq_order数据库创建表message
CREATE TABLE `message` (
  `order_id` int(11) DEFAULT NULL,
  `status` varchar(20) DEFAULT NULL,
  `order_content` varchar(100) DEFAULT NULL,
  `unique_id` int(11) DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8
  1. service包下的类

MQOrderService.java

package com.vinjcent.rabbitmq.service;

import com.vinjcent.rabbitmq.mq.OrderMqService;
import com.vinjcent.rabbitmq.pojo.Order;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@SuppressWarnings("all")
@Service
public class MqOrderService {

    @Autowired
    private OrderDatabaseService orderService;

    @Autowired
    private OrderMqService orderMqService;

    public void createOrder(Order order) throws Exception {

        // 1.订单信息,插入订单
        orderService.saveOrder(order);
        // 2.通过http接口发送订单信息到运单系统
        orderMqService.sendMessage(order);
    }

}
  1. mq包下的类

OrderMqService.java

package com.vinjcent.rabbitmq.mq;


import com.vinjcent.rabbitmq.pojo.Order;
import com.vinjcent.rabbitmq.utils.JsonUtil;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;

@SuppressWarnings("all")
@Service
public class OrderMqService {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Autowired
    private RabbitTemplate rabbitTemplate;



    public void sendMessage(Order order) {
        rabbitTemplate.convertAndSend("order_fanout_exchange","", JsonUtil.obj2String(order),new CorrelationData(order.getOrderId().toString()));
    }


    // 该注解被用来修饰一个非静态的void方法,被@PostConstruct修饰的方法会在服务器加载Servlet的时候运行,
    // 并且只会被服务器执行一次,PostConstruct在构造函数之后执行,init()方法之前执行
    @PostConstruct
    public void regCallback() {
        // 消息发送成功以后,给予生产者的消息回执,来确保生产者的可靠性
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback(){

            @Override
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                System.out.println("cause" + cause);
                // 如果ack为true代表消息已经收到
                String orderId = correlationData.getId();

                if (!ack){
                    // 这里可能要进行其它的方式存储
                    System.out.println("MQ队列答应失败,orderId是: " + orderId);
                    return;
                }

                String sql = "update message set status = 1 where order_id = ?";
                int count = jdbcTemplate.update(sql, orderId);
                try {
                    if (count == 1){
                        System.out.println("本地消息状态修改成功,消息成功投递到消息队列中...");
                    }
                } catch (Exception e) {
                    System.out.println("本地消息状态修改失败,出现异常: " + e.getMessage());
                }
            }
        });
    }
}
  1. utils包的类

JsonUtil.java

package com.vinjcent.rabbitmq.utils;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;


import java.text.SimpleDateFormat;

@Slf4j
public class JsonUtil {
    private static ObjectMapper objectMapper = new ObjectMapper();
    // 日起格式化
    private static final String STANDARD_FORMAT = "yyyy-MM-dd HH:mm:ss";
    static {
        //对象的所有字段全部列入
        objectMapper.setSerializationInclusion(JsonInclude.Include.ALWAYS);
        //取消默认转换timestamps形式
        objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);
        //忽略空Bean转json的错误
        objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS,false);
        //所有的日期格式都统一为以下的样式，即yyyy-MM-dd HH:mm:ss
        objectMapper.setDateFormat(new SimpleDateFormat(STANDARD_FORMAT));
        //忽略 在json字符串中存在，但是在java对象中不存在对应属性的情况。防止错误
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES,false);
    }

    /**
     * 对象转Json格式字符串
     * @param obj 对象
     * @return Json格式字符串
     */
    public static <T> String obj2String(T obj) {
        if (obj == null) {
            return null;
        }
        try {
            return obj instanceof String ? (String) obj : objectMapper.writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            log.warn("Parse Object to String error : {}", e.getMessage());
            return null;
        }
    }

    /**
     * 对象转Json格式字符串(格式化的Json字符串)
     * @param obj 对象
     * @return 美化的Json格式字符串
     */
    public static <T> String obj2StringPretty(T obj) {
        if (obj == null) {
            return null;
        }
        try {
            return obj instanceof String ? (String) obj : objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            log.warn("Parse Object to String error : {}", e.getMessage());
            return null;
        }
    }

    /**
     * 字符串转换为自定义对象
     * @param str 要转换的字符串
     * @param clazz 自定义对象的class对象
     * @return 自定义对象
     */
    public static <T> T string2Obj(String str, Class<T> clazz){
        if(StringUtils.isEmpty(str) || clazz == null){
            return null;
        }
        try {
            return clazz.equals(String.class) ? (T) str : objectMapper.readValue(str, clazz);
        } catch (Exception e) {
            log.warn("Parse String to Object error : {}", e.getMessage());
            return null;
        }
    }

}
  1. 测试运行用例
@SpringBootTest
class RabbitmqOrderServiceApplicationTests {

    @Autowired
    OrderService orderService;

    @Autowired
    MQOrderService mqOrderService;

    @Test
    void contextLoads() {
    }

    @Test
    void testMQCreateOrder() throws Exception {
        Order order = new Order(15,1,"今晚吃鸡!",new Date());
        mqOrderService.createOrder(order);
        System.out.println("订单创建成功......");
    }

}
  1. 调式

在这里插入图片描述

在这里插入图片描述

查看数据库数据

order表

在这里插入图片描述

message表

在这里插入图片描述

由于发送消息给rabbitmq服务还没有响应回执，所以此时的订单状态是"0"

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

此时的状态修改成了"1"，完成了订单消息的投递

11.4 RabbitMQ - 高级 - 可靠消费

在这里插入图片描述

测试用例

在rabbitmq-dispatcher-service工程下

在这里插入图片描述

  1. 在utils包下的类
package com.vinjcent.rabbitmq.utils;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;

import java.text.SimpleDateFormat;

@Slf4j
public class JsonUtil {
    private static ObjectMapper objectMapper = new ObjectMapper();
    // 日起格式化
    private static final String STANDARD_FORMAT = "yyyy-MM-dd HH:mm:ss";
    static {
        //对象的所有字段全部列入
        objectMapper.setSerializationInclusion(JsonInclude.Include.ALWAYS);
        //取消默认转换timestamps形式
        objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);
        //忽略空Bean转json的错误
        objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS,false);
        //所有的日期格式都统一为以下的样式，即yyyy-MM-dd HH:mm:ss
        objectMapper.setDateFormat(new SimpleDateFormat(STANDARD_FORMAT));
        //忽略 在json字符串中存在，但是在java对象中不存在对应属性的情况。防止错误
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES,false);
    }

    /**
     * 对象转Json格式字符串
     * @param obj 对象
     * @return Json格式字符串
     */
    public static <T> String obj2String(T obj) {
        if (obj == null) {
            return null;
        }
        try {
            return obj instanceof String ? (String) obj : objectMapper.writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            log.warn("Parse Object to String error : {}", e.getMessage());
            return null;
        }
    }

    /**
     * 对象转Json格式字符串(格式化的Json字符串)
     * @param obj 对象
     * @return 美化的Json格式字符串
     */
    public static <T> String obj2StringPretty(T obj) {
        if (obj == null) {
            return null;
        }
        try {
            return obj instanceof String ? (String) obj : objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            log.warn("Parse Object to String error : {}", e.getMessage());
            return null;
        }
    }

    /**
     * 字符串转换为自定义对象
     * @param str 要转换的字符串
     * @param clazz 自定义对象的class对象
     * @return 自定义对象
     */
    public static <T> T string2Obj(String str, Class<T> clazz){
        if(StringUtils.isEmpty(str) || clazz == null){
            return null;
        }
        try {
            return clazz.equals(String.class) ? (T) str : objectMapper.readValue(str, clazz);
        } catch (Exception e) {
            log.warn("Parse String to Object error : {}", e.getMessage());
            return null;
        }
    }

}
  1. 在mq包下的类
package com.vinjcent.rabbitmq.mq;

import com.rabbitmq.client.Channel;
import com.vinjcent.rabbitmq.pojo.Order;
import com.vinjcent.rabbitmq.service.DispatchService;
import com.vinjcent.rabbitmq.utils.JsonUtil;
import org.springframework.amqp.core.Correlation;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.support.AmqpHeaders;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.stereotype.Service;

@SuppressWarnings("all")
@Service
public class OrderMqConsumer {

    @Autowired
    private DispatchService dispatchService;

    private int count = 1;

    @RabbitListener(queues = {"order.queue"})
    public void messageConsumer(String ordermsg, Channel channel,
                                CorrelationData correlationData,
                                @Header (AmqpHeaders.DELIVERY_TAG) long deliveryTag) throws Exception {
        // 1.获取消息队列的消息
        System.out.println("收到的MQ消息是: " + ordermsg + ",count = " + count++);
        // 2.获取订单服务的信息
        Order order = JsonUtil.string2Obj(ordermsg, Order.class);
        // 3.获取订单但id
        Integer orderId = order.getOrderId();
        // 4.保存订单
        dispatchService.dispatch(orderId);

    }

}

  1. 运行工程rabbitmq-dispatcher-service

  2. 查看控制台从消息队列中获取的消息

在这里插入图片描述

拓展

由于在创建订单记录又或者在创建消息记录时，已经将消息推送到队列中了，但是数据库中的数据状态可能没有修改，这时需要创建一个定时任务，每个几分钟或几秒查询数据库的消息记录状态，确保已经推送到队列中的消息在数据库中完成了修改

在rabbitmq-order-service工程下

  1. 添加实体类Message.java
package com.vinjcent.rabbitmq.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Message {

    private Integer orderId;
    private String status;
    private String orderContent;
    private Integer uniqueId;

}
  1. 添加定时任务类TaskSchedule.java
package com.vinjcent.rabbitmq.task;

import com.vinjcent.rabbitmq.pojo.Message;
import com.vinjcent.rabbitmq.utils.JsonUtil;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;

import java.util.List;

@SuppressWarnings("all")
@EnableScheduling
public class TaskSchedule {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Autowired
    private RabbitTemplate rabbitTemplate;

    // 每个5分钟将消息为"0"状态的消息记录,进行查询,然后投递到消息队列中
    @Scheduled(cron = "* 0/5 * * * ?")
    public void sendMessage() {

        // 查询所有为"0"状态的记录
        String sql = "select * from message where status = 0";
        List<Message> messages = jdbcTemplate.queryForList(sql, Message.class);

        // 循环将消息推送到消息队列中
        messages.forEach(message -> {
//            rabbitTemplate.convertAndSend("order_fanout_exchange","", JsonUtil.obj2String(order),new CorrelationData(order.getOrderId().toString()));

        });

    }

}

11.5 RabbitMQ - 高级 - 可靠消费重试机制

由于在接受消息的时候出现了故障，会进入死循环，并触发 RabbitMQ 的重试机制，队列里的消息一直无法应答

解决消息重试的几种方案

  1. 控制重发的次数
  2. try + catch + 手动ack
  3. try + catch + 手动ack + 死信队列处理

控制重发的次数

在rabbitmq-dispatcher-service工程下

修改application.yml文件

server:
  port: 9000

spring:
  # 服务应用名称
  application:
    name: rabbitmq_dispatch
  # 配置数据源
  datasource:
    url: jdbc:mysql://localhost:3306/rabbitmq_dispatch?useSSL=false&useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
    username: root
    password: 123456
    driver-class-name: com.mysql.jdbc.Driver
  rabbitmq:
#    单机
#    port: 5673
#    host: 192.168.159.100
    # 集群部署
    addresses: 192.168.159.100:5673,192.168.159.100:5674,192.168.159.100:5675
    username: admin
    password: admin
    virtual-host: /
    # 手动开启ack,让程序去控制MQ的消息和重发、删除、转移
    listener:
      simple:
        # 手动ack机制,默认是none
        acknowledge-mode: manual
        retry:
          # 开启重试模式,默认为false
          enabled: true
          # 最大重试数,默认时3次
          max-attempts: 10
          # 重试间隔时间
          initial-interval: 2000ms
    # 消息确认机制
    publisher-confirm-type: correlated

try + catch + 手动ack

测试用例

在rabbitmq-dispatcher-service工程下

  1. 在mq包下的类

OrderMqConsumer.java模拟消费信息时出现异常

package com.vinjcent.rabbitmq.mq;

import com.rabbitmq.client.Channel;
import com.vinjcent.rabbitmq.pojo.Order;
import com.vinjcent.rabbitmq.service.DispatchService;
import com.vinjcent.rabbitmq.utils.JsonUtil;
import org.springframework.amqp.core.Correlation;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.support.AmqpHeaders;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.stereotype.Service;

@SuppressWarnings("all")
@Service
public class OrderMqConsumer {

    @Autowired
    private DispatchService dispatchService;

    private int count = 1;

    @RabbitListener(queues = {"order.queue"})
    public void messageConsumer(String ordermsg, Channel channel,
                                CorrelationData correlationData,
                                @Header (AmqpHeaders.DELIVERY_TAG) long deliveryTag) throws Exception {
        try {
            // 1.获取消息队列的消息
            System.out.println("收到的MQ消息是: " + ordermsg + ",count = " + count++);
            // 2.获取订单服务的信息
            Order order = JsonUtil.string2Obj(ordermsg, Order.class);
            // 3.获取订单id
            Integer orderId = order.getOrderId();
            // 4.保存订单
            dispatchService.dispatch(orderId);
            System.out.println(1 / 0);  // 模拟异常
            // 关闭ack机制
            channel.basicAck(deliveryTag, false);
        } catch (Exception e) {
            // 如果出现异常的情况下,则判断为无应答,根据实际的情况去进行重发
            // 参数1: 消息的tag   参数2: false 多条处理   参数3: requeue 重发
            // false 不会重发,false的话会扔掉消息,将消息转移到死信队列,
            // true 会死循环重发,建议如果使用true的话,不要加try/catch,否则会造成死循环,并且在配置文件中设置的重复次数失效
            channel.basicNack(deliveryTag, false, false);
        }

    }

}
  1. 在rabbitmq-order-service工程下向队列发送一条消息
@SpringBootTest
class RabbitmqOrderServiceApplicationTests {

    @Autowired
    OrderService orderService;

    @Autowired
    MqOrderService mqOrderService;

    @Test
    void contextLoads() {
    }

    @Test
    void testMQCreateOrder() throws Exception {
        Order order = new Order(15,1,"今晚吃鸡!",new Date());
        mqOrderService.createOrder(order);
        System.out.println("订单创建成功......");
    }

}

原初始队列的数据

在这里插入图片描述

发送消息后的记录

在这里插入图片描述

  1. 运行rabbitmq-dispatcher-service工程

在这里插入图片描述

虽然在接收完消息之后有算数异常，但还是进行了一次队列里的信息消费，不会遇到异常回滚。如果在接收完消息之后，对数据进行操作，可能会导致数据的不一致性、不准确性

在这里插入图片描述

在这里插入图片描述

try + catch + 手动ack + 死信队列处理

用例测试

  1. 在rabbitmq-order-service工程下的mqConfig包添加配置类
package com.vinjcent.rabbitmq.mqConfig;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;

@Configuration
public class RabbitMQConfiguration {

    // 死信队列
    @Bean
    public FanoutExchange deadExchange(){
        return new FanoutExchange("dead_order_fanout_exchange",true,false);
    }

    @Bean
    public Queue deadOrderQueue(){
        return new Queue("dead.order.queue", true);
    }

    @Bean
    public Binding bindingDeadOrder() {
        return BindingBuilder.bind(deadOrderQueue()).to(deadExchange());
    }

    // 将订单队列与死信队列绑定
    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange("order_fanout_exchange",true,false);
    }

    @Bean
    public Queue orderQueue(){
        HashMap<String, Object> args = new HashMap<>();
        args.put("x-dead-letter-exchange", "dead_order_fanout_exchange");
        return new Queue("order.queue", true, false, false, args);
    }

    @Bean
    public Binding bindingOrder() {
        return BindingBuilder.bind(orderQueue()).to(fanoutExchange());
    }

}

在rabbitmq-dispatcher-service工程下

  1. 处理死信队列里的消息
package com.vinjcent.rabbitmq.mq;

import com.rabbitmq.client.Channel;
import com.vinjcent.rabbitmq.pojo.Order;
import com.vinjcent.rabbitmq.service.DispatchService;
import com.vinjcent.rabbitmq.utils.JsonUtil;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.support.AmqpHeaders;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.stereotype.Service;

@SuppressWarnings("all")
@Service
public class DeadMqConsumer {

    @Autowired
    private DispatchService dispatchService;

    private int count = 1;

    @RabbitListener(queues = {"dead.order.queue"})
    public void messageConsumer(String ordermsg, Channel channel,
                                CorrelationData correlationData,
                                @Header (AmqpHeaders.DELIVERY_TAG) long deliveryTag) throws Exception {
        try {
            // 1.获取消息队列的消息
            System.out.println("收到的MQ消息是: " + ordermsg);
            // 2.获取订单服务的信息
            Order order = JsonUtil.string2Obj(ordermsg, Order.class);
            // 3.获取订单id
            Integer orderId = order.getOrderId();
            // 4.这里原本已经将消息存入数据库当中,应该是执行更新操作!需要换成update
            dispatchService.dispatch(orderId);
            // 关闭ack机制
            channel.basicAck(deliveryTag, false);
        } catch (Exception e) {
            System.out.println("人工干预");
            System.out.println("发短信预警");
            System.out.println("同时把消息转移到别的存储DB");
            // 移除死信队列中的消息
            channel.basicNack(deliveryTag,false, false);

        }

    }

}

在这里插入图片描述

  1. 在rabbitmq-order-service工程下向队列发送一条消息

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

debug测试运行过程

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

Naijia_OvO
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
rabbitmq-c-0.7.1.tar.gz
09-29
RabbitMQ是一种开源的消息代理和队列服务器，广泛应用于分布式系统中的异步处理、任务队列以及微服务架构中。 RabbitMQ-C库主要提供了以下功能： 1. **连接管理**：建立和维护到RabbitMQ服务器的TCP连接，支持SSL/...
RabbitMQ高级 -- 分布式事务
weixin_46724181的博客
04-12 3673
一、引言 前端时间因为忙着学吉他~ 就耽误正事了~ 现在就赶紧补回来~~ 二、目录
如何用 RabbitMQ 解决分布式事务？
Java5658的博客
06-14 1265
要说哪种分布式事务处理方案效率高，必然绕不开消息中间件！基于消息中间件的两阶段提交方案，通常用在高并发场景下。这种方式通过牺牲数据的强一致性换取性能的大幅提升，不过实现这种方式的成本和复杂度是比较高的，使用时还要看实际业务情况。...
分布式事务
m0_67463445的博客
05-04 1817
本地消息表的最终一致方案采用BASE原理，保证事务最终一致。在一致性方面，允许一段时间内的不一致，但最终会一致。本地消息表实现分布式事务应该是网站前台使用最多的，其核心思想是将分布式事务拆分成本地事务进行处理，这种思路是来源于ebay。使用本地消息表，消息生产方，需要额外建一个消息表，并记录消息发送状态。消息表和业务数据要在一个事务里提交，也就是说他们要在一个数据库里面。然后消息会经过MQ发送到消息的消费方。如果消息发送失败，会进行重试发送。消息消费方，需要处理这个消息，并完成自己的业务逻辑。
数据库事务提交后才发送MQ消息解决方案
Nicky's blog
11-02 962
在项目开发中常常会遇到在一个有数据库操作的方法中，发送MQ消息，如果这种情况消息队列效率比较快，就会出现数据库事务还没提交，消息队列已经执行业务，导致不一致问题。举个应用场景，我们提交一个订单，将流水号放在MQ里，MQ监听到后就会查询订单去做其它业务，如果这时候数据库事务还没提交，也就是没生成订单流水，MQ监听到消息就去执行业务，查询订单，肯定会出现业务不一致问题。
RabbitMQ高级特性（二）：RabbitMQ事务（概述）
HaleyTiger的博客
12-28 2768
RabbitMQ高级特性（三）：RabbitMQ事务（概述） RabbitMQ支持事务(transaction)，RabbitMQ中与事务机制有关的方法有三个：txSelect(), txCommit()以及txRollback()。 （1）txSelect用于将当前channel设置成transaction模式，通过调用tx.select方法开启事务模式。 （2）txCommit用于提交事务。当开启了事务模式后，只有当一个消息被所有的镜像队列保存完毕后，RabbitMQ才会调用tx.commit-ok
rabbitmq实战学习-rabbitmqlearning.zip
11-07
1. 事务：虽然AMQP不直接支持事务，但RabbitMQ提供了一种事务模拟机制，保证消息的顺序性。 2. 多级消息队列：通过消息死信队列，可以处理未被正确处理的消息，提高系统的健壮性。 3. 路由与过滤：Topic交换机支持...
rabbitmq-jar包
06-29
RabbitMQ是一个开源的消息代理和队列服务器，它基于高级消息队列协议（AMQP）标准，被广泛用于处理分布式系统中的异步任务和消息传递。在这个“rabbitmq-jar包”中，我们有两个版本的AMQP客户端库，分别是`amqp-...
2-分布式高级篇 _SpringCloud系统_spring_谷粒商城_分布式_分布式高级篇_
10-03
使用SpringBoot+SpringCloud并配套SpringCloud Alibaba系列，引入全套微服务治理方案：Nacos注册中心/配置中心、Sentinel流量保护系统、Seata分布式事务&RabbitMQ柔性事务方案、SpringCloud-Gateway网关、Feign...
rabbitmq-ack
最新发布
12-17
4. **分布式事务**：`code(分布式事务）-01.zip`可能涉及到如何在RabbitMQ中实现跨多个操作的事务一致性。虽然RabbitMQ本身不直接支持分布式事务，但可以结合其他技术如两阶段提交或补偿事务策略来实现。ACK在此处的...
RabbitMQ怎么处理消息事务
yuanchengfu0910的博客
06-09 2399
注意：在生产者中，我们使用 channel.txCommit() 提交事务，而在消费者中，我们使用 channel.basicAck() 手动确认消息或 channel.basicReject() 手动拒绝消息并重新入队。通过将通道（Channel）设置为事务模式，所有发送到该通道的消息都将在提交事务之前被缓存，并且在提交事务后才会被投递到交换机中。在确认监听器中，可以处理确认（ack）和未确认（nack）消息的逻辑，确保消息发送的可靠性。当收到未确认消息时，表示消息发送失败，可以进行相应的处理。
RabbitMQ 高级：分布式事务详解案例——可靠生产（二）
祝我飞黄腾达
03-24 909
在上一篇博文中，我们讲述了分布式事务存在的问题，本文将用一个简单的demo代码演示分布式系统存在的事务问题，以及通过MQ的方式进行解决，达成数据最终一致性方案 项目架构 系统：订单服务（负责用户订单的接收）、运单中心（负责订单的配送） 使用技术：SpringBoot + SpringMVC + JdbcTemplate 项目内容：两套系统，订单系统下单，配送系统骑手接单 功能描述：订单系统创建订单，封装订单信息远程调用rpc接口（配送系统），配送服务通过订单详情进行对订单配送等追踪.
rabbitMQ:事务性消息发送和接收
weixin_59334478的博客
11-07 1518
事务消息与数据库的事务类似，只是MQ中的消息是要保证消息是否会全部发送成功，防止丢失消息的一种策略。1.channel.txSelect()声明启动事务模式；3.channel.txRollback()回滚事务；2.channel.txCommint()提交事务；1.通过AMQP提供的事务机制实现；2.使用发送者确认模式实现；
基于RabbitMQ解决分布式事务
Tiger_Paul的博客
03-03 2477
1、可查询操作：服务操作具有全局唯一的标识，操作唯一的确定的时间。 2、幂等操作：重复调用多次产生的业务结果与调用一次产生的结果相同。一是通过业务操作实现幂等性，二是系统缓存所有请求与处理的结果，最后是检测到重复请求之后，自动返回之前的处理结果。 3、TCC操作：Try阶段，尝试执行业务，完成所有业务的检查，实现一致性；预留必须的业务资源，实现准隔离性。Confirm阶段：真正的去执行业务，不做任何检查，仅适用Try阶段预留的业务资源，Confirm操作还要满足幂等性。Cancel阶段：取消执行业务，释放T
【RabbitMQ Learning Journey】分布式事务解决方案思想
记录开发学习笔记
02-29 530
（MQ解决分布式事务，内容来源于蚂蚁课堂） 案例： 点外卖案例。 用户下单后，调用订单服务，然后订单服务调用派单服务通知外卖人员送单， 这时候订单系统与派单系统采用MQ异步通讯。 消费者端 RabbitMQ分布式事务解决方案，最终一致性思想。(可以暂时不一致，但是最终要一致) 需要保证以下三要素 1、确认生产者一定要将数据投递到MQ服务器中（采用MQ消息确认机制） 2、MQ消费者消息能够正...
RabbitMQ踩坑 生产者事务提交在消费者之后
a805727141的博客
06-15 588
本人在使用RabbitMQ的过程中遇到了一些问题，记录下来给大家参考。
一个基于RabbitMQ的可复用的事务消息方案
Throwable
02-05 4269
前提 分布式事务是微服务实践中一个比较棘手的问题，在笔者所实施的微服务实践方案中，都采用了折中或者规避强一致性的方案。参考Ebay多年前提出的本地消息表方案，基于RabbitMQ和MySQL（JDBC）做了轻量级的封装，实现了低入侵性的事务消息模块。本文的内容就是详细分析整个方案的设计思路和实施。环境依赖如下： JDK1.8+ spring-boot-start-web:2.x.x、spring...
记录基于RabbitMQ消息队列的分布式事务解决方案 - MQ分布式消息中间件实战，seata以外的分布式事务实现方式
qq_50896685的博客
09-27 610
通用性强拓展性强方案成熟基于消息中间件，只适合异步场景消息处理会有延迟，需要业务上能够容忍尽量避免分布式事务;尽量将非核心事务做成异步;保证事务的ACID四大原则；实现分布式事务有很多种方式，看大家习惯用哪一种，使用消息中间件是一种很基本也很可靠的方式。
seta-分布式事务介绍
qq_36575363的博客
02-09 8259
一.前置知识 2.分布式事务 分布式事务指事务的参与者、支持事务的服务器、资源服务器以及事务管理器分别位于不同的分布式系统的不同节点之上,且属于不同的应用，分布式事务需要保证这些操作要么全部成功，要么全部失败。本质上来说，分布式事务就是为了保证不同数据库的数据一致性。 3. 分布式一致性 3.1 引言 在分布式系统中，为了保证数据的高可用, 通常我们会将数据保留多个副本(replica), 这些副本会放置在不同的物理机器上。为了对用户提供正确的curd等语意，我们需要保证这些放置在不同
RabbitMQ实践指南：分布式消息传递
此外，书中还涵盖了高级主题，如工作队列、发布/订阅模式、直连和主题交换机、持久化和事务机制，以及如何利用RabbitMQ实现服务间的通信和故障恢复策略。 在分布式系统的设计和实施部分，作者强调了RabbitMQ在系统...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Naijia_OvO

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值