利用RabbitMQ实现分布式事务

最新推荐文章于 2024-01-25 01:52:15 发布
最新推荐文章于 2024-01-25 01:52:15 发布
阅读量480 收藏 2
点赞数 1
文章标签： 大数据 json 数据库
原文链接：http://www.cnblogs.com/hhhshct/p/11496536.html
版权

　　实现要点：1、构建本地消息表及定时任务，确保消息可靠发送；2、RabbitMQ可靠消费；3、redis保证幂等

　　两个服务：订单服务和消息服务

　　订单服务消息可靠发送

　　使用springboot构建项目，相关代码如下

spring:
  datasource:
    druid:
      url: jdbc:postgresql://127.0.0.1:5432/test01?characterEncoding=utf-8
      username: admin
      password: 123456
      driver-class-name: org.postgresql.Driver
      initial-size: 1
      max-active: 20
      max-wait: 6000
      pool-prepared-statements: true
      max-pool-prepared-statement-per-connection-size: 20
      connection-properties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=2000
      min-idle: 1
      time-between-eviction-runs-millis: 60000
      min-evictable-idle-time-millis: 300000
      validation-query: select 1
      test-while-idle: true
      test-on-borrow: false
      test-on-return: false
  rabbitmq:
    username: guest
    password: guest
    host: 127.0.0.1
    virtual-host: /
    port: 5672
    publisher-confirms: true
server:
  port: 8087
logging:
  level:
    org.springframework.jdbc.core.JdbcTemplate: DEBUG
　　　　 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>
        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>postgresql</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.8</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.47</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
package com.jlwj.mqtransaction.bean;

import lombok.Data;

import java.io.Serializable;

/**
 * @author hehang on 2019-06-27
 * @descriptionsdf
 */

@Data
public class OrderBean implements Serializable {

    private String orderNo;
    private String orderInfo;
}
package com.jlwj.mqtransaction.service;

import com.alibaba.fastjson.JSON;
import com.jlwj.mqtransaction.bean.OrderBean;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.MessageDeliveryMode;
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;

/**
 * @author hehang on 2019-07-01
 * @description发动消息到MQ
 */
@Service
@Slf4j
public class RabbitMQService {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @PostConstruct
    private void initRabbitTemplate(){
        //设置消息发送确认回调，发送成功后更新消息表状态
        rabbitTemplate.setConfirmCallback((CorrelationData correlationData, boolean ack, String cause) -> {
            log.info(String.valueOf(ack));
            if(ack){
                String sql = "update t_confirm set send_status = ? where id = ?";
                jdbcTemplate.update(sql,1,correlationData.getId());
            }
        });
    }
    public void sendMessage(OrderBean orderBean){
        rabbitTemplate.convertAndSend("orderExchange","orderRoutingKey", JSON.toJSONString(orderBean),
                message -> { message.getMessageProperties().setDeliveryMode(MessageDeliveryMode.PERSISTENT);return message;},
                new CorrelationData(orderBean.getOrderNo()));
    }

}
package com.jlwj.mqtransaction.service;

import com.alibaba.fastjson.JSON;
import com.jlwj.mqtransaction.bean.OrderBean;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.MessageDeliveryMode;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.PostConstruct;

/**
 * @author hehang on 2019-06-27
 * @description订单服务，简单期间不再写接口
 */

@Service
@Slf4j
public class OrderService {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Autowired
    private RabbitMQService rabbitMQService;

    //注意加事务注解
    @Transactional(propagation = Propagation.REQUIRED)
    public void save(OrderBean orderBean){
        String sql1 = "insert into t_order(order_no,order_info) values (?,?)";
        String sql2 = "insert into t_confirm(id,message_info,send_status) values (?,?,?)";
        jdbcTemplate.update(sql1,orderBean.getOrderNo(),orderBean.getOrderInfo());
        jdbcTemplate.update(sql2,orderBean.getOrderNo(), JSON.toJSONString(orderBean),0);
        rabbitMQService.sendMessage(orderBean);
    }


}
package com.jlwj.mqtransaction.service;

import com.jlwj.mqtransaction.bean.OrderBean;
import lombok.extern.slf4j.Slf4j;
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.Scheduled;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @author hehang on 2019-07-01
 * @description 定时扫描confirm表，重复发送未发送的消息
 */
@Service
@Slf4j
public class OrderScheduleService {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Autowired
    private RabbitMQService rabbitMQService;

    //定时扫描记录表，将发送状态为0的消息再次发送，甚至可以记录重发次数，必要时人工干预，生产环境中需要单独部署定时任务
    @Scheduled(cron ="30/30 * * * * ?" )
    public void scanOrder(){
        log.info("定时扫面confirm表");
        String sql = "select o.* from t_order o join t_confirm c on o.order_no = c.id where c.send_status = 0";
        List<OrderBean> orderBeanList = jdbcTemplate.queryForList(sql, OrderBean.class);
        for (OrderBean orderBean : orderBeanList) {
            rabbitMQService.sendMessage(orderBean);
        }
    }
}

　　消息服务相关代码

spring:
  rabbitmq:
    username: guest
    password: guest
    host: 127.0.0.1
    virtual-host: /
    port: 5672
    listener:
      simple:
        acknowledge-mode: manual
  redis:
    host: 127.0.0.1
      port: 6379
      timeout: 5000
      jedis:
        pool:
          max-idle: 8
          min-idle: 0
          max-active: 8
          max-wait: 1
<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.8</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.47</version>
        </dependency>
package com.jlwj.messageservice.config;

import org.springframework.amqp.core.*;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.amqp.support.converter.MessageConverter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

/**
 * @author hehang on 2019-06-27
 * @descriptionmq配置类
 */
@Configuration
public class RabbitConfig {

    /**
     * 死信队列
     * @return
     */
    @Bean
    public Queue dlQueue(){
        return QueueBuilder.durable("dlQueue")
                .build();
    }

    @Bean
    public DirectExchange dlExchange(){
        return (DirectExchange) ExchangeBuilder.directExchange("dlExchange").build();
    }
    @Bean
    public Binding dlMessageBinding(){
        return BindingBuilder.bind(dlQueue()).to(dlExchange()).with("dlRoutingKey");
    }

    
    @Bean
    public DirectExchange messageDirectExchange() {
        return (DirectExchange) ExchangeBuilder.directExchange("orderExchange")
                .durable(true)
                .build();
    }

    @Bean
    public Queue messageQueue() {
        return QueueBuilder.durable("orderQueue")
                //配置死信
                .withArgument("x-dead-letter-exchange","dlExchange")
                .withArgument("x-dead-letter-routing-key","dlRoutingKey")
                .build();
    }

    @Bean
    public Binding messageBinding() {
        return BindingBuilder.bind(messageQueue())
                .to(messageDirectExchange())
                .with("orderRoutingKey");
    }

}
package com.jlwj.messageservice.listener;

import com.alibaba.fastjson.JSON;
import com.jlwj.messageservice.bean.OrderBean;
import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.support.AmqpHeaders;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.messaging.handler.annotation.Payload;
import org.springframework.stereotype.Component;

import java.io.IOException;

/**
 * @author hehang on 2019-06-28
 * @description订单监听
 */
@Component
@Slf4j

public class OrderListener {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;


    @RabbitListener(queues = "orderQueue")
    public void HandlerMessage(Channel channel, @Payload String message, @Header(AmqpHeaders.DELIVERY_TAG) long tag,
                                @Header(AmqpHeaders.REDELIVERED) boolean reDelivered ) throws IOException {
        log.info(message);
        OrderBean orderBean = JSON.parseObject(message,OrderBean.class);
        try {
            log.info("收到的消息为{}",JSON.toJSONString(orderBean));
            //保证幂等性
            if(stringRedisTemplate.opsForValue().get(orderBean.getOrderNo())==null){
                sendMessage(orderBean);
                stringRedisTemplate.opsForValue().set(orderBean.getOrderNo(),"1");
            }
            channel.basicAck(tag,false);
        } catch (Exception e) {
            if(reDelivered){
                log.info("消息已重复处理失败：{}",message);
                channel.basicReject(tag,false);
            }else{
                log.error("消息处理失败",e);
                //重新入队一次
                channel.basicNack(tag,false,true);
            }

        }
    }


    private void sendMessage(OrderBean orderBean)throws Exception{
        if(orderBean.getOrderNo().equals("0007")){
            int a =3/0;
        }
        log.info("模拟发送短信");
    }
}
package com.jlwj.messageservice.listener;

import com.alibaba.fastjson.JSON;
import com.jlwj.messageservice.bean.OrderBean;
import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;
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.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.messaging.handler.annotation.Payload;
import org.springframework.stereotype.Component;

import java.io.IOException;

/**
 * @author hehang on 2019-06-28
 * @description订单监听
 */
@Component
@Slf4j

public class DlListener {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;


    @RabbitListener(queues = "dlQueue")
    public void HandlerMessage(Channel channel, Message message, @Header(AmqpHeaders.DELIVERY_TAG) long tag) throws IOException {
        log.info(new String(message.getBody()));
        //人工处理死信队列中的消息
        handlerDl(new String(message.getBody()));
        channel.basicAck(tag,false);
    }


    private void handlerDl(String message){
        log.info("发送邮件，请求人工干预:{}",message);
    }
}

 

转载于:https://www.cnblogs.com/hhhshct/p/11496536.html

weixin_30426065
关注
Rabbitmq实现多系统间的分布式事务，保证数据一致性
STIll_ly的博客
01-30 3525
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 解决分布式事务？
m0_71777195的博客
06-30 4443
要说哪种分布式事务处理方案效率高，必然绕不开消息中间件！基于消息中间件的两阶段提交方案，通常用在高并发场景下。这种方式通过牺牲数据的强一致性换取性能的大幅提升，不过实现这种方式的成本和复杂度是比较高的，使用时还要看实际业务情况。今天小编想通过一个简单的案例，来和大家聊一聊如何通过消息中间件来处理分布式事务。先来说说整体思路。有一个名词叫做消息驱动的微服务，相信很多小伙伴都听说过。怎么理解呢？在微服务系统中，服务之间的互相调用，我们可以使用 HTTP 的方式，例如 OpenFeign，也可以使用 RPC 的方
分布式系统消息中间件——RabbitMQ的使用进阶篇
yufaxingxing的博客
09-25 278
文章导航-readme 分布式系统消息中间件——RabbitMQ的使用进阶篇 前言 上一篇文章 (https://www.cnblogs.com/hunternet/p/9668851.html) 简单总结了分布式系统中的消息中间件以及RabbitMQ的基本使用，这篇文章主要总结一下RabbitMQ在日常项目开发中比较常用的几个特性。 系列文章 分布式系统消息中间件——Rabbi...
rabbitmq实现分布式事务
qq_32300143的博客
06-08 277
代码理论参考链接https://blog.csdn.net/pastxu/article/details/124531593自我理解:生产端:通过建立一张消息表，消息表中的状态来实现数据是否发送到rabbitmq中，利用rabbitmq的消息确认机制更新消息发送状态，未发送成功的消息可以采用定时任务扫描重新发送这样保证生产端能闭环成功发送消息到rabbitmq消费端: 同样利用rabbitmq的消息确认机制保证消息能够被消费，未正常消费的消息可以通过死信队列进行人工消费处理...
使用RabbitMQ实现分布式事务
dianbiao3588的博客
05-26 503
RabbitMQ解决分布式事务思路： 案例： 经典案例，以目前流行点外卖的案例，用户下单后，调用订单服务，让后订单服务调用派单系统通知送外卖人员送单，这时候订单系统与派单系统采用MQ异步通讯。 RabbitMQ解决分布式事务原理：采用最终一致性原理。 需要保证以下三要素 1、确认生产者一定要将数据投递到MQ服务器中（采用MQ消息确认机制） 2、MQ消费者消息能够正确消费消...
使用RabbitMQ+延迟队列实现分布式事务的最终一致性方案
04-13
通过这种方式，我们能够在保证用户体验的同时，利用RabbitMQ的延迟队列实现分布式事务的最终一致性。这种方案适用于对即时一致性要求不高，但对系统稳定性和可用性要求较高的场景。不过，需要注意的是，虽然延迟队列...
基于rabbitmq实现的分布式事务解决方案是独立消息服务的最终一致性案例源码.zip
最新发布
03-03
在这个场景中，我们关注的是基于RabbitMQ实现的分布式事务解决方案，它是一种独立消息服务确保最终一致性的案例。RabbitMQ是广泛应用的消息中间件，用于解耦应用程序，使得它们可以通过消息进行通信，而无需直接交互...
java 使用RabbitMQ 实现分布式事务
04-24
使用 RabbitMQ 实现分布式事务的方式，一般采用的是基于 AMQP 协议的两阶段提交（Two-phase commit，2PC）。 在 RabbitMQ 中，使用插件 rabbitmq_consistent_hash_exchange 可以实现基于 Consistent Hash 的分布式...
rabbitmq分布式事务
12-01
基于rabbit和本地消息表实现可靠消息一致性分布式事务，项目下载下来直接可以用了，已经包含了配置文件和数据库脚本，有问题的可以给我私信。项目架构springboot、nacos、rabbitMq、redis、MySQL
RabbitMq实现分布式事务
shuangyueliao的专栏
04-15 4951
RabbitMq实现分布式事务的原理是最终保持一致性 外卖的订单服务通过rabbitmq异步调派单服务 rabbitmq保证事务一致性应满足以下要求 confirm机制保证订单服务投递的消息到达MQ 手动ack机制保证派单服务不丢失MQ发过来的信息 MQ的补偿重试机制降低了因网络抖动的原因而订单----派单服务执行失败 如果订单服务执行失败而回滚，那么补单消费者将补单重新插入一条数据进入订单表...
基于RabbitMQ解决分布式事务
Tiger_Paul的博客
03-03 2537
1、可查询操作：服务操作具有全局唯一的标识，操作唯一的确定的时间。 2、幂等操作：重复调用多次产生的业务结果与调用一次产生的结果相同。一是通过业务操作实现幂等性，二是系统缓存所有请求与处理的结果，最后是检测到重复请求之后，自动返回之前的处理结果。 3、TCC操作：Try阶段，尝试执行业务，完成所有业务的检查，实现一致性；预留必须的业务资源，实现准隔离性。Confirm阶段：真正的去执行业务，不做任何检查，仅适用Try阶段预留的业务资源，Confirm操作还要满足幂等性。Cancel阶段：取消执行业务，释放T
RabbitMQ——解决分布式事务问题，RabbitMQ的重要作用之一！！！通过可靠生产和可靠消费来完美解决！
我热爱学习，也乐于分享。无论是科技前沿的洞见，还是生活中的小技巧，我都会在这里与你分享。我相信，知识就是力量，而分享则能让这份力量得到更好的传递。
12-14 1608
分布式事务是指涉及多个独立的计算机系统（也称为节点或参与者）之间的事务处理。在分布式系统中，每个节点可能各自拥有自己的数据存储和事务管理机制。分布式事务的目标是保证在跨多个节点执行的一系列操作可以以一致和可靠的方式执行和提交，即使在面对故障或并发操作时也能保持数据的完整性和一致性。实现分布式事务可以采用两阶段提交（Two-Phase Commit）协议或三阶段提交（Three-Phase Commit）协议等机制。这些协议通过协调参与者之间的状态和决策来实现分布式事务的一致性。
「项目实战」有一说一这才是RabbitMQ实现分布式事务的正确姿势(附源码)
AntizZ 的博客
12-01 1137
有一说一 U1S1 不懂就问 导盲犬禁止入内是给犬看的还是盲人看的？
RabbitMQ高级 -- 分布式事务
weixin_46724181的博客
04-12 3948
一、引言 前端时间因为忙着学吉他~ 就耽误正事了~ 现在就赶紧补回来~~ 二、目录
实战：RabbitMQ的分布式事务处理
AI天才研究院
01-25 1470
1.背景介绍 分布式事务处理是一种在多个节点之间处理事务的方法，它可以确保在分布式系统中的多个节点之间的事务处理的一致性和完整性。在分布式系统中，事务可能涉及多个节点，这使得事务处理变得复杂。因此，分布式事务处理是一项重要的技术，它可以确保在分布式系统中的事务处理的一致性和完整性。 RabbitMQ是一种开源的消息队列系统，它可以用于分布式系统中的事务处理。在这篇文章中，我们将讨论Rabbit...
RabbitMQ实现分布式事务
王小白来了
09-27 1823
前言
RabbitMQ实现多系统间的分布式事务，保证数据一致性
Java知音
09-07 502
点击关注公众号，实用技术文章及时了解一、实验环境Lunix系统：Centos7.5安装软件：rabbitmq开发工具：IDEA二、实验目的Rabbitmq实现多系统间的分布式事务，保证数据...
记录基于RabbitMQ消息队列的分布式事务解决方案 - MQ分布式消息中间件实战，seata以外的分布式事务实现方式
qq_50896685的博客
09-27 728
通用性强拓展性强方案成熟基于消息中间件，只适合异步场景消息处理会有延迟，需要业务上能够容忍尽量避免分布式事务;尽量将非核心事务做成异步;保证事务的ACID四大原则；实现分布式事务有很多种方式，看大家习惯用哪一种，使用消息中间件是一种很基本也很可靠的方式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值