分布式事务

2021-01-17 17:20:42 16 收藏
分类专栏： 分布式事务 spring boot 文章标签： 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42282792/article/details/112597285
版权

一、分布式事务概述

1.CAP原理
2.ACID原理与BASE原理
3.基于XA协议两段提交（不建议使用）
4.事务补偿机制
5.基于本地消息表的最终一致方案
6.基于MQ消息队列的最终一致方案

二、分库分表所引发的问题

1.业务被拆分
2.多个独立数据库之间，事务不统一
3.数据可能出现不一致的情况
应用场景举例：
在这里插入图片描述

三、分布式事务解决方案

（一）、基于XA协议的两段提交的分布式事务解决方案
1.简介：
XA协议是有X/Open组织提出的分布式事务的规范
由一个事务管理器（TM）和多个资源管理器（RM）组成
提交分为两个阶段：prepare和commit，流程如下：
在这里插入图片描述
在这里插入图片描述
2.优缺点
优点：
保证了数据的强一致性
缺点：
commit阶段出现问题时，事务出现不一致，需要人工处理
效率低下，性能与本地事务相差10倍
3.兼容性
Mysql5.7以上均支持XA协议
Mysql Connector/J 5.0以上支持XA协议
Java系统中数据源采用Atomikos

4.项目示例
项目文件结构：
在这里插入图片描述

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.8.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>xa-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>xa-demo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.0</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jta-atomikos</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-maven-plugin</artifactId>
                <version>1.3.7</version>
                <dependencies>
                    <dependency>
                        <groupId>mysql</groupId>
                        <artifactId>mysql-connector-java</artifactId>
                        <version>8.0.17</version>
                    </dependency>
                </dependencies>
            </plugin>
        </plugins>
    </build>

</project>

ConfigDB131.java

package com.xa.xademo.config;

import com.atomikos.icatch.jta.UserTransactionImp;
import com.atomikos.icatch.jta.UserTransactionManager;
import com.atomikos.jdbc.AtomikosDataSourceBean;
import com.mysql.cj.jdbc.MysqlXADataSource;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.transaction.jta.JtaTransactionManager;

import javax.sql.DataSource;
import javax.sql.XADataSource;
import javax.transaction.UserTransaction;
import java.io.IOException;

/**
 * Created with IntelliJ IDEA.
 * User: Administrator
 * Date: 2021/1/14
 * Time: 22:31
 * Description: No Description
 */
@Configuration
@MapperScan(value = "com.xa.xademo.db131.dao", sqlSessionFactoryRef ="sqlSessionFactoryBean131")
public class ConfigDB131 {

    @Bean("db131")
    public DataSource db131() {
        MysqlXADataSource xaDataSource = new MysqlXADataSource();
        xaDataSource.setUser("xa");
        xaDataSource.setPassword("xatest");
        xaDataSource.setUrl("jdbc:mysql://192.168.56.131:3306/xa_131");

        AtomikosDataSourceBean atomikosDataSourceBean = new AtomikosDataSourceBean();

        atomikosDataSourceBean.setXaDataSource(xaDataSource);
        return atomikosDataSourceBean;
    }

    @Bean("sqlSessionFactoryBean131")
    public SqlSessionFactoryBean sqlSessionFactoryBean(@Qualifier("db131") DataSource dataSource) throws IOException {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dataSource);
        ResourcePatternResolver resourceResolver = new PathMatchingResourcePatternResolver();
        sqlSessionFactoryBean.setMapperLocations(resourceResolver.getResources("mybatis/db131/*.xml"));
        return sqlSessionFactoryBean;
    }

    @Bean("xaTransaction")
    public JtaTransactionManager jtaTransactionManager() {

        UserTransaction userTransaction = new UserTransactionImp();
        UserTransactionManager userTransactionManager = new UserTransactionManager();
        return new JtaTransactionManager(userTransaction, userTransactionManager);
    }

}

ConfigDB132.java

package com.xa.xademo.config;

import com.atomikos.icatch.jta.UserTransactionImp;
import com.atomikos.icatch.jta.UserTransactionManager;
import com.atomikos.jdbc.AtomikosDataSourceBean;
import com.mysql.cj.jdbc.MysqlXADataSource;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.transaction.jta.JtaTransactionManager;

import javax.sql.DataSource;
import javax.transaction.UserTransaction;
import java.io.IOException;

/**
 * Created with IntelliJ IDEA.
 * User: Administrator
 * Date: 2021/1/14
 * Time: 22:31
 * Description: No Description
 */
@Configuration
@MapperScan(value = "com.xa.xademo.db131.dao", sqlSessionFactoryRef ="sqlSessionFactoryBean132")
public class ConfigDB132 {

    @Bean("db132")
    public DataSource db132() {
        MysqlXADataSource xaDataSource = new MysqlXADataSource();
        xaDataSource.setUser("xa");
        xaDataSource.setPassword("xatest");
        xaDataSource.setUrl("jdbc:mysql://192.168.56.132:3306/xa_132");

        AtomikosDataSourceBean atomikosDataSourceBean = new AtomikosDataSourceBean();

        atomikosDataSourceBean.setXaDataSource(xaDataSource);
        return atomikosDataSourceBean;
    }

    @Bean("sqlSessionFactoryBean132")
    public SqlSessionFactoryBean sqlSessionFactoryBean(@Qualifier("db132") DataSource dataSource) throws IOException {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dataSource);
        ResourcePatternResolver resourceResolver = new PathMatchingResourcePatternResolver();
        sqlSessionFactoryBean.setMapperLocations(resourceResolver.getResources("mybatis/db132/*.xml"));
        return sqlSessionFactoryBean;
    }


}

模拟业务
XAService.java文件

package com.xa.xademo.service;

import com.xa.xademo.db131.dao.XA131Mapper;
import com.xa.xademo.db131.model.XA131;
import com.xa.xademo.db132.dao.XA132Mapper;
import com.xa.xademo.db132.model.XA132;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;

/**
 * Created with IntelliJ IDEA.
 * User: Administrator
 * Date: 2021/1/14
 * Time: 23:08
 * Description: No Description
 */
@Service
public class XAService {

    @Resource
    private XA131Mapper xa131Mapper;
    @Resource
    private XA132Mapper xa132Mapper;


    @Transactional(transactionManager = "xaTransaction")
    public void testXA(){

        XA131 xa131 = new XA131();
        xa131.setId(1);
        xa131.setName("11111");
        xa131Mapper.insert(xa131);

        XA132 xa132 = new XA132();
        xa132.setId(1);
        xa132.setName("22222");
        xa132Mapper.insert(xa132);
    }
}

(二)、基于事务补偿机制的分布式事务解决方案
前言： 在提到分布式事务之前，需要特别说明一下，如果数据库由Mycat或者sharding-jdbc代理的，那么他们是默认支持分布式事务的，无需做额外的配置，就像使用普通的事务一样即可。

事务补偿机制原理：
针对每个操作，都要注册一个对应的补偿（撤销）操作；
失败时，调用补偿操作，回滚数据；
在这里插入图片描述
（三）、基于本地消息表的分布式事务解决方案

1.原理
采用BASE原理,保证事务最终一致
在一致性方面，允许一段时间内的不一致，但最终会一致
因此，实际业务中需要根据实时性等要求，判断该解决方案是否一致

2.实现
基于本地消息表的方案中，将本事务外操作，记录在消息表中
其他事务，提供操作接口
定时任务轮询本地消息表，将未执行的消息发送给操作接口
操作接口处理成功，返回成功标识，处理失败返回失败标识
定时任务接受到返回标识，更新消息状态
定时任务按照一定的周期，反复执行
对于屡次失败的消息可以设置最大失败次数
超过最大失败次数的消息，定时任务不再执行
等待人工处理

**3.架构图 **
在这里插入图片描述

4.优缺点
优点：事务拆分，避免了分布式事务，实现了最终一致性
缺点：需要确保重试时的幂等性

（四）、基于MQ消息队列的分布式事务解决方案
1.原理
流程，原理基本与”本地消息表“一致
2.与本地消息表的区别：
本地消息表改为了MQ消息队列；
定时任务替换为消费者。

3.总体流程：
在这里插入图片描述
4.优缺点
实时性高，可靠性高，不需要依赖于定时任务
对于公司内部的系统而言，MQ的形式可能更加实用

已标记关键词 清除标记
Spring JTA分布式事务实现
王浩的技术博客
08-26 5556
1.概述 Java Transaction API，通常称为JTA，是用于管理 Java中的事务的API 。它允许我们以资源无关的方式启动，提交和回滚事务。 根据用于管理事务的底层实现，Spring中的事务策略可以分为两个主要部分： 单连接器策略（相当于本地事务管理器） - 底层技术使用单连接器。例如，JDBC使用连接级事务、Hibernate以及JDO使用会话级事务。可以应用使用AOP和拦截器...
表情包
插入表情
还能输入1000个字符
相关推荐
Spring分布式事务实现
阳光岛主
09-01 1万+
分布式事务是指操作多个数据库之间的事务，spring的org.springframework.transaction.jta.JtaTransactionManager，提供了分布式事务支持。如果使用WAS的JTA支持，把它的属性改为WebSphere对应的TransactionManager。     在tomcat下，是没有分布式事务的，不过可以借助于第三方软件jotm（Java Open T
分布式事务JTA实现
java_resolver的博客
04-12 2662
一个项目操作多个数据源的情况下，如果对事务进行管理：    分布式事务解决方案：jta + atomikos 结构目录：只需要jta 目录即可，其余可忽略1.  引入以下jar包：（前提：引入ssm需要的jar包）            &lt;!-- 分布式事务 jta+ atomikos --&gt; &lt;dependency&gt; &lt;groupId&gt;com.atomi...
分布式事务的解决方案总结
做最专业的总结 大师
05-07 1万+
一、分布式事物 1.1 数据库事务 原子性(Atomicity )、一致性( Consistency )、隔离性或独立性( Isolation)和持久性(Durabilily)，简称就是ACID 1.2 分布式事物产生原因 分布式事物产生的原因 分布式事务产生的场景 在分布式系统，都会垂直拆分数据库，分为支付数据库、订单数据库、积分数据库、优惠全数据库等，业务组成，分为多...
分布式事务原理及解决方案
weixin_34199335的博客
11-20 1163
1 引言 分布式事务是企业集成中的一个技术难点，也是每一个分布式系统架构中都会涉及到的一个东西，特别是在这几年越来越火的微服务架构中，几乎可以说是无法避免，本文就围绕单机事务，分布式事务以及分布式事务的处理方式来展开。 2 事务 事务提供一种“要么什么都不做，要么做全套（All or Nothing）”的机制，她有ACID四大特性 原子性（Atomicity）：事务作为一个整体被执行，包含在其中...
调研 | 5种分布式事务解决方案优缺点对比
BoCloud博云
07-25 5840
背景 分布式事务是企业集成中的一个技术难点，也是每一个分布式系统架构中都会涉及到的一个东西，特别是在微服务架构中，几乎可以说是无法避免。 ACID 指数据库事务正确执行的四个基本要素： 原子性（Atomicity） 一致性（Consistency） 隔离性（Isolation） 持久性（Durability） CAP CAP原则又称...
第一次有人把“分布式事务”讲的这么简单明了
weixin_33725515的博客
08-13 724
不知道你是否遇到过这样的情况，去小卖铺买东西，付了钱，但是店主因为处理了一些其他事，居然忘记你付了钱，又叫你重新付。又或者在网上购物明明已经扣款，但是却告诉我没有发生交易。这一系列情况都是因为没有事务导致的。这说明了事务在生活中的一些重要性。有了事务，你去小卖铺买东西，那就是一手交钱一手交货。有了事务，你去网上购物，扣款即产生订单交易。事务的具体定义事务提供一种机制将一个活动涉及的所有操作纳入到一...
分布式锁、事务和分布式事务概念汇总
ostar_liang的专栏
07-30 7091
  1、锁: 单进程的系统中，存在多线程同时操作一个公共变量，此时需要加锁对变量进行同步操作，保证多线程的操作线性执行消除并发修改。解决的是单进程中的多线程并发问题。 2、分布式锁: 只要的应用场景是在集群模式的多个相同服务，可能会部署在不同机器上，解决进程间安全问题，防止多进程同时操作一个变量或者数据库。解决的是多进程的并发问题。   3、事务 解决一个会话过程中，上下文的修改对所...
SpringCloud分布式事务处理方案
zhangxing
08-11 5万+
1.场景还原 笔者在公司最近的一个项目采用springcloud框架搭建微服务架构，这势必会引发分布式事务处理的思考，目前处理分布式主流方案tcc及消息的最终一致性；今天笔者集成github上较为流行的tx-lcn分布式处理框架，它是基于redis的一种补偿型处理方案 2.实现方案 ①先截图，下载该框架 从github上的starts数量来看，目前还是较多开发者采用了这种方案...
分布式事务几种实现方式
至尊宝
08-05 4万+
1.分布式事务产生的背景 2.X/OpenDTP事务模型 3.Mysql事务处理过程 4. 2PC协议 5.3PC协议 6.分布式事务的实现 - atomikos 7.MQ实现最终一致性 7.1消息重复消费解决方案 8.LCN实现 1.分布式事务产生的背景 根据业务需求需要对业务进行拆分,例如将一个大应用拆分成用户模块,订单模块,商品模块,每个模块都有自己的数据库,在用户...
kafka事务使用和编程示例
qq_36382679的博客
09-08 120
kafka事务使用和编程示例 一、概述 ​ Kafka事务特性是指一系列的生产者生产消息和消费者提交偏移量的操作在一个事务中，或者说是一个原子操作，生产消息和提交偏移量同时成功或者失败。 注意：kafka事务和DB事务。 在理解消息的事务时，一直处于一个错误理解是，把操作db的业务逻辑跟操作消息当成是一个事务，如下所示： void kakfa_in_tranction(){ // 1.kafa的操作：读取消息或生产消息 kafkaOperation(); // 2.db操作 dbO
分布式事务和分布式锁
peng_0129的博客
04-19 1万+
一 分布式事务解决方案目前比较多的解决方案有几个：一、结合MQ消息中间件实现的可靠消息最终一致性二、TCC补偿性事务解决方案三、最大努力通知型方案第一种方案：可靠消息最终一致性，需要业务系统结合MQ消息中间件实现，在实现过程中需要保证消息的成功发送及成功消费。即需要通过业务系统控制MQ的消息状态第二种方案：TCC补偿性，分为三个阶段TRYING-CONFIRMING-CANCELING。每个阶段做...
如何高效解决分布式事务问题的？TCC 如果出现网络连不通怎么办？XA 的一致性如何保证？
wenlin_xie的专栏
02-26 1715
如何高效解决分布式事务问题的？TCC 如果出现网络连不通怎么办？XA 的一致性如何保证？   面试题 分布式事务了解吗？你们是如何解决分布式事务问题的？ 面试官心理分析 只要聊到你做了分布式系统，必问分布式事务，你对分布式事务一无所知的话，确实会很坑，你起码得知道有哪些方案，一般怎么来做，每个方案的优缺点是什么。 现在面试，分布式系统成了标配，而分布式系统带来的分布式事务也成了标配...
分布式事务解决方案：2PC，TCC以及基于消息的最终一致性
Master_Dk的博客
04-24 470
各种形态的分布式事务 分布式事务有多种主流形态，包括： 基于消息实现的分布式事务 基于补偿实现的分布式事务 基于TCC实现的分布式事务 基于SAGA实现的分布式事务 基于2PC实现的分布式事务 这些形态的原理已经在很多文章中进行了剖析，用“分布式事务”关键字就能搜到对应的文章，本文不再赘述这些形态的原理，并将重点放在如何根据业务选择对应的分布式事务形态上。 分布式事务解决方案汇总 接下来，以一...
分布式事务解决方案和原理
leeco的博客
08-20 288
分布式事务解决方案和原理,以及引发的思考 一. 背景： 我们都知道, 在以前的 all in one 的项目开发模式下, 所有事务问题都是本地事务问题, 基本上利用mysql的优化方案和java提供的API, 可以解决绝大多数本地事务问题，而在现在的分布式及微服务的模式下，很多事务问题就不是简单的本地事务问题了，正是由于在为服务环境下存在的网络延迟问题，机器不可用问题，以及一次操作由多个系统协同完成而产生的各类问题，导致了逻辑上的一次事务违反了ACID中的特性问题。 之前的文章介绍了事务中的ACID和事务的
分布式事务及解决方案
小雨的博客
05-10 6215
分布式事务的概念 要了解分布式事务，我们要先清楚什么是事务。事务就是多个原子操作的组合，他们就像是一条绳上的蚂蚱，要么一起生，要么一起死，在事务中，如果其中一个操作执行失败，那么剩下的操作都不再执行，而之前执行过的操作也需要回滚。至于分布式事务，顾名思义就是包含对分布式系统中不同节点的操作的事务。 事务的目的 我们使用事务的目的是为了防止一些执行失败的操作对数据造成影响，产生错误数据。比较典...
spring cloud 分布式事务攻略(高级篇) ：淘宝支付实战
08-11
----------------------------面试提醒--------------------------------------- 如果你的简历出现dubbo或spring cloud的字眼,通常面试官都会问你分布式事务的问题，因为你项目用了dubbo或spring cloud分布式框架，就必定要解决分布式事务的难题。 如果你不想被面试官虐，请学好分布式事务技能。
©️2020 CSDN 皮肤主题: 数字20 设计师:CSDN官方博客 返回首页