基于XA协议的分布式事务

最新推荐文章于 2024-05-04 23:27:58 发布

飘狐

最新推荐文章于 2024-05-04 23:27:58 发布

阅读量683

点赞数

分类专栏： springboot 分布式事务 aotmikos 文章标签： spring spring boot java

本文链接：https://blog.csdn.net/hamster204/article/details/110163918

版权

springboot 同时被 3 个专栏收录

10 篇文章 0 订阅

订阅专栏

分布式事务

2 篇文章 0 订阅

订阅专栏

aotmikos

2 篇文章 0 订阅

订阅专栏

前言

最近在项目中使用了分布式事务，就稍加整理了一下以博客的形式共享出来。目前实现分布事务有很多方式包括2PC、TCC、事务消息等。因为业务需要我项目中采用的是传统的2PC方式的解决方案。2PC既两阶段提交，又叫做 XA Transactions，MySQL从5.5版本开始支持，SQL Server 2005 开始支持，Oracle 7 开始支持，它的优点是强一直性，缺点则是降低了可用性，这里由于本篇博客以实践为主就不过多赘述理论知识了。在前一篇博客中我介分享了单体工程多数据源、多事务的实现方式，而本篇博客将在此基础上将其升级为统一的分布式事务。

逻辑示意

实践

本Demo基于springboot 2.1.1，集成了jta-atomikos、mybatis-plus、druid，数据库使用mysql。为了能够更加简明清晰以下内容只列出了关键代码的实现，有需要全部代码的同学可以通过此链接https://gitee.com/microapps/jta/tree/v1.0.0下载查看。

第一步，在pom.xml中加入依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jta-atomikos</artifactId>
</dependency>

JTA（java Transaction API）是JavaEE 13 个开发规范之一。java 事务API，允许应用程序执行分布式事务处理——在两个或多个网络计算机资源上访问并且更新数据。而Atomikos TransactionsEssentials 是一个为Java平台提供增值服务的并且开源类事务管理器。

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>microapps.com.cn</groupId>
    <artifactId>atomic</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.1.RELEASE</version>
        <relativePath />
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <!--
              解决该错误：failed to create pooled connection - DBMS down or unreachable
              springboot2.1.x版本默认的mysql-connector-java 版本比较高 8.0.x，需要降低版本
            -->
            <version>6.0.6</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.2.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jta-atomikos</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.9</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>

</project>

第二步，在application.yml中定义数据源

配置文件的内容虽然看起来很多但真正重要的是one和two两个数据源的定义方式，其他内容为druid连接池的配置。

server:
  port: 8080
spring:
  datasource:
    one:
      driverClassName: com.mysql.cj.jdbc.Driver
      url:  jdbc:mysql://localhost:3306/test1?useSSL=false&serverTimezone=UTC&characterEncoding=UTF-8
      username: root
      password: root
      type: com.alibaba.druid.pool.DruidDataSource
      initialSize: 1
      minIdle: 3
      maxActive: 20
      # 配置获取连接等待超时的时间，单位是毫秒
      maxWait: 60000
      # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
      timeBetweenEvictionRunsMillis: 60000
      # 配置一个连接在池中最小生存的时间，单位是毫秒
      minEvictableIdleTimeMillis: 30000
      # 用来检测连接是否有效的sql
      validationQuery: select 'x'
      # 申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。
      testWhileIdle: true
      # 申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能
      testOnBorrow: false
      # 归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能
      testOnReturn: false
      # 打开PSCache，并且指定每个连接上PSCache的大小
      poolPreparedStatements: true
      maxPoolPreparedStatementPerConnectionSize: 20
      # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
      filters: stat,wall,slf4j
      # 通过connectProperties属性来打开mergeSql功能；慢SQL记录
      connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
    two:
      driverClassName: com.mysql.cj.jdbc.Driver
      url:  jdbc:mysql://localhost:3306/test2?useSSL=false&serverTimezone=UTC&characterEncoding=UTF-8
      username: root
      password: root
      type: com.alibaba.druid.pool.DruidDataSource
      initialSize: 1
      minIdle: 3
      maxActive: 20
      # 配置获取连接等待超时的时间，单位是毫秒
      maxWait: 60000
      # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
      timeBetweenEvictionRunsMillis: 60000
      # 配置一个连接在池中最小生存的时间，单位是毫秒
      minEvictableIdleTimeMillis: 30000
      # 用来检测连接是否有效的sql
      validationQuery: select 'x'
      # 申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。
      testWhileIdle: true
      # 申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能
      testOnBorrow: false
      # 归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能
      testOnReturn: false
      # 打开PSCache，并且指定每个连接上PSCache的大小
      poolPreparedStatements: true
      maxPoolPreparedStatementPerConnectionSize: 20
      # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
      filters: stat,wall,slf4j
      # 通过connectProperties属性来打开mergeSql功能；慢SQL记录
      connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000

第三步，在代码中配置和使用分布式事务

在工程中有多少个数据源就需要配置多少个DataSourceConfig

OneDataSourceConfig.java

package microapps.com.cn.conf;

import com.alibaba.druid.pool.xa.DruidXADataSource;
import com.alibaba.druid.support.http.StatViewServlet;
import com.atomikos.jdbc.AtomikosDataSourceBean;
import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
import lombok.Data;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;

import javax.sql.DataSource;
import java.sql.SQLException;


/**
 * 主数据源配置
 */
@Data
@Configuration
@ConfigurationProperties(prefix = "spring.datasource.one")
@MapperScan(basePackages = OneDataSourceConfig.PACKAGE
        , sqlSessionFactoryRef = "oneSqlSessionFactory")
public class OneDataSourceConfig {

    /**
     * 配置多数据源 关键就在这里 这里配置了不同的数据源扫描不同mapper
     */
    /**
     * 配置多数据源 关键就在这里 这里配置了不同的数据源扫描不同mapper
     */
    static final String PACKAGE = "microapps.com.cn.**.mapper.one";
    static final String MAPPER_LOCATION = "classpath:mapper/one.xml";

    /**
     * 连接数据库信息 这个其实更好的是用配置中心完成
     */
    private String driverClassName;
    private String url;
    private String username;
    private String password;
    private int initialSize;
    private int minIdle;
    private int maxActive;
    private int maxWait;
    private int timeBetweenEvictionRunsMillis;
    private int minEvictableIdleTimeMillis;
    private String validationQuery;
    private boolean testWhileIdle;
    private boolean testOnBorrow;
    private boolean testOnReturn;
    private boolean poolPreparedStatements;
    private int maxPoolPreparedStatementPerConnectionSize;
    private String filters;
    private String connectionProperties;


    @Bean(name = "oneDataSource")
    @Primary //标志这个 Bean 如果在多个同类 Bean 候选时，该 Bean 优先被考虑。
    public DataSource dataSource() {
        DruidXADataSource dataSource = new DruidXADataSource();
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        dataSource.setDriverClassName(driverClassName);

        //具体配置
        dataSource.setInitialSize(initialSize);
        dataSource.setMinIdle(minIdle);
        dataSource.setMaxActive(maxActive);
        dataSource.setMaxWait(maxWait);
        dataSource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
        dataSource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
        dataSource.setValidationQuery(validationQuery);
        dataSource.setTestWhileIdle(testWhileIdle);
        dataSource.setTestOnBorrow(testOnBorrow);
        dataSource.setTestOnReturn(testOnReturn);
        dataSource.setPoolPreparedStatements(poolPreparedStatements);
        dataSource.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);

        /**
         * 这个是用来配置 druid 监控sql语句的 非常有用 如果你有两个数据源 这个配置哪个数据源就监控哪个数据源的sql 同时配置那就都监控
         */
        try {
            dataSource.setFilters(filters);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        dataSource.setConnectionProperties(connectionProperties);
        // 设置JTA
        AtomikosDataSourceBean xaDataSource = new AtomikosDataSourceBean();
        xaDataSource.setXaDataSource(dataSource);
        xaDataSource.setUniqueResourceName("oneDataSource");
        return xaDataSource;
    }

    @Primary
    @Bean(name = "oneSqlSessionFactory")
    public MybatisSqlSessionFactoryBean sqlSessionFactory(@Qualifier("oneDataSource") DataSource dataSource)
            throws Exception {
        MybatisSqlSessionFactoryBean mybatisPlus = new MybatisSqlSessionFactoryBean();
        mybatisPlus.setDataSource(dataSource);
        mybatisPlus.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(OneDataSourceConfig.MAPPER_LOCATION));
        return mybatisPlus;
    }

    /**
     * 配置 Druid 监控界面
     */
    @Bean
    public ServletRegistrationBean statViewServlet(){
        ServletRegistrationBean srb =
                new ServletRegistrationBean(new StatViewServlet(),"/druid/*");
        //设置控制台管理用户
        srb.addInitParameter("loginUsername","root");
        srb.addInitParameter("loginPassword","root");
        //是否可以重置数据
        srb.addInitParameter("resetEnable","false");
        return srb;
    }
}

TwoDataSourceConfig.java

package microapps.com.cn.conf;

import com.alibaba.druid.pool.xa.DruidXADataSource;
import com.atomikos.jdbc.AtomikosDataSourceBean;
import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
import lombok.Data;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;

import javax.sql.DataSource;
import java.sql.SQLException;


/**
 * 主数据源配置
 */
@Data
@Configuration
@ConfigurationProperties(prefix = "spring.datasource.two")
@MapperScan(basePackages = TwoDataSourceConfig.PACKAGE
        , sqlSessionFactoryRef = "twoSqlSessionFactory")
public class TwoDataSourceConfig {

    /**
     * 配置多数据源 关键就在这里 这里配置了不同的数据源扫描不同mapper
     */
    static final String PACKAGE = "microapps.com.cn.**.mapper.two";
    static final String MAPPER_LOCATION = "classpath:mapper/two.xml";

    /**
     * 连接数据库信息 这个其实更好的是用配置中心完成
     */
    private String driverClassName;
    private String url;
    private String username;
    private String password;
    private int initialSize;
    private int minIdle;
    private int maxActive;
    private int maxWait;
    private int timeBetweenEvictionRunsMillis;
    private int minEvictableIdleTimeMillis;
    private String validationQuery;
    private boolean testWhileIdle;
    private boolean testOnBorrow;
    private boolean testOnReturn;
    private boolean poolPreparedStatements;
    private int maxPoolPreparedStatementPerConnectionSize;
    private String filters;
    private String connectionProperties;


    @Bean(name = "twoDataSource")
    public DataSource dataSource() {
        DruidXADataSource  dataSource = new DruidXADataSource();
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        dataSource.setDriverClassName(driverClassName);
        dataSource.setInitialSize(initialSize);
        dataSource.setMinIdle(minIdle);
        dataSource.setMaxActive(maxActive);
        dataSource.setMaxWait(maxWait);
        dataSource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
        dataSource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
        dataSource.setValidationQuery(validationQuery);
        dataSource.setTestWhileIdle(testWhileIdle);
        dataSource.setTestOnBorrow(testOnBorrow);
        dataSource.setTestOnReturn(testOnReturn);
        dataSource.setPoolPreparedStatements(poolPreparedStatements);
        dataSource.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);
        /**
         * 这个是用来配置 druid 监控sql语句的,如果你有两个数据源 这个配置哪个数据源就监控哪个数据源的sql 同时配置就都监控
         */
        try {
            dataSource.setFilters(filters);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        dataSource.setConnectionProperties(connectionProperties);
        // 设置JTA
        AtomikosDataSourceBean xaDataSource = new AtomikosDataSourceBean();
        xaDataSource.setXaDataSource(dataSource);
        xaDataSource.setUniqueResourceName("twoDataSource");
        return xaDataSource;
    }

    @Bean(name = "twoSqlSessionFactory")
    public MybatisSqlSessionFactoryBean sqlSessionFactory(@Qualifier("twoDataSource") DataSource dataSource)
            throws Exception {
        MybatisSqlSessionFactoryBean mybatisPlus = new MybatisSqlSessionFactoryBean();
        mybatisPlus.setDataSource(dataSource);
        mybatisPlus.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(TwoDataSourceConfig.MAPPER_LOCATION));
        return mybatisPlus;
    }

}

JTAServiceImpl.java

在使用时只需在方法上声明@Transactional注解即可非常简单，本例中定义的save方法其功能是向one和two两个数据源中同时插入数据，在执行过程中如遇异常则同时回滚。

package microapps.com.cn.service.impl;

import microapps.com.cn.mapper.one.OneMapper;
import microapps.com.cn.mapper.two.TwoMapper;
import microapps.com.cn.service.IJTAService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

/**
 * @Description: 测试分布式事务服务接口
 * @Author: liuhe
 * @Date: 2020/11/19
 */
@Service
public class JTAServiceImpl implements IJTAService {

    @Autowired
    private OneMapper oneMapper;

    @Autowired
    private TwoMapper twoMapper;


    /**
     * 测试保存方法
     */
    @Transactional
    public void save() {
        oneMapper.insert("1","aa");
        int i = 1/0;
        twoMapper.insert("1","bb");
    }
}

飘狐

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
基于XA协议的分布式事务

前言最近在项目中使用了分布式事务，就稍加整理了一下以博客的形式共享出来。目前实现分布事务有很多方式包括2PC、TCC、事务消息等。因为业务需要我项目中采用的是传统的2PC方式的解决方案。2PC既两阶段提交，又叫做 XA Transactions，MySQL从5.5版本开始支持，SQL Server 2005 开始支持，Oracle 7 开始支持，它的优点是强一直性，缺点则是降低了可用性，这里由于本篇博客以实践为主就不过多赘述理论知识了。在前一篇博客中我介分享了单体工程多数据源、多事务的实...
复制链接

扫一扫