springboot+JTA+atomikos多数据源分布式事务管理

已于 2024-08-16 17:09:14 修改
阅读量1.7k 收藏 20
点赞数 14
分类专栏： Java 文章标签： spring boot 分布式 后端
于 2024-08-16 16:49:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/java_csdnn/article/details/141261476
版权

一、项目需求

        1、同时操作两个数据库，一个在本地服务器，一个在云服务器。

        2、数据库数据是同步的，两个数据库同时做update、insert等操作时，无论哪个数据库操作失败，要求两个数据库数据同时回滚。

        3、两个数据库均为SQL server数据库。

二、特殊要求

        1、数据库支持XA事务。网上其他教程都很复杂，但是这个博主写的很不错，不会配的可以参考一下：无法创建 XA 控制连接。错误:“找不到存储过程 'master..xp_sqljdbc_xa_init_ex'_com.microsoft.sqlserver.jdbc.sqlserverexception: 无-CSDN博客

        2、设置允许远程操作数据库。

        3、云服务器在控制台配置入站或出站规则，tcp协议，开放数据库端口。本地数据库在防火墙配置入站出站规则。

三、简单认识XA、JTA和Atomikos

XA

        XA是定义于数据库的分布式事务处理规范，XA事务支持不同数据库之间实现分布式事务。

JTA

        JTA（Java Transaction API）：是Java平台上一个标准API，用于管理和控制分布式事务的执行流程。它是数据库XA事务在Java的一个映射。

        核心类：
javax.transaction.UserTransaction：暴露给应用使用，用来启动、提交、回滚事务。
javax.transaction.TransactionManager：提供给事务管理器的接口，用于协调和控制分布式事务的执行过程。
javax.transaction.XAResource：表示一个资源管理器，用于管理和操作资源。
javax.transaction.Xid：用于唯一标识一个分布式事务。

Atomikos

        Atomikos是一个开源的事务管理器，用于管理和控制分布式事务的执行过程。Atomikos可以解决，在同一个应用下，连接多个数据库，实现分布式事务。

四、项目案例

项目目录：

0、pom配置：

<?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.6.13</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>

	<groupId>com.gloyel</groupId>
	<artifactId>twodbgn</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>twodbgn</name>
	<description>twodbgn</description>

	<properties>
		<java.version>17</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.2.2</version>
		</dependency>
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<version>1.18.32</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter-test</artifactId>
			<version>3.0.3</version>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-jta-atomikos</artifactId>
			<version>2.6.13</version>
		</dependency>
		<dependency>
			<groupId>com.baomidou</groupId>
			<artifactId>dynamic-datasource-spring-boot-starter</artifactId>
			<version>3.6.0</version>
		</dependency>
		<dependency>
			<groupId>jakarta.transaction</groupId>
			<artifactId>jakarta.transaction-api</artifactId>
			<version>1.3.3</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-tx</artifactId>
			<version>5.3.23</version>
		</dependency>
		<dependency>
			<groupId>com.microsoft.sqlserver</groupId>
			<artifactId>mssql-jdbc</artifactId>
			<version>11.2.0.jre17</version>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>
</project>

1、bean

        User是实体类，与数据库表对应可自行配置

2、config

        JTA 事务配置，固定配置，通过JTATransactionManager实现分布式事务

import javax.transaction.TransactionManager;
import javax.transaction.UserTransaction;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.DependsOn;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.jta.JtaTransactionManager;
import com.atomikos.icatch.jta.UserTransactionImp;
import com.atomikos.icatch.jta.UserTransactionManager;

/**
 * JTA 事务配置
 */
@Configuration
public class AtomikosConfig {
    @Bean(name = "userTransaction")
    public UserTransaction userTransaction() throws Throwable {
        UserTransactionImp userTransactionImp = new UserTransactionImp();
        userTransactionImp.setTransactionTimeout(10000);
        return userTransactionImp;
    }

    @Bean(name = "atomikosTransactionManager")
    public TransactionManager atomikosTransactionManager() throws Throwable {
        UserTransactionManager userTransactionManager = new UserTransactionManager();
        userTransactionManager.setForceShutdown(false);
        return userTransactionManager;
    }

    @Bean(name = "transactionManager")
    @DependsOn({ "userTransaction", "atomikosTransactionManager" })
    public PlatformTransactionManager transactionManager() throws Throwable {
        UserTransaction userTransaction = userTransaction();
        TransactionManager atomikosTransactionManager = atomikosTransactionManager();
        return new JtaTransactionManager(userTransaction, atomikosTransactionManager);
    }
}

3、controller

        控制层

import com.gloyel.twodbgn.Service.UserServiceImpl;
import com.gloyel.twodbgn.Service.UserService;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

@RestController
@RequestMapping("/user")
public class UserController {

    @Resource
    private UserService userService=new UserServiceImpl();

    @RequestMapping(value = "/userList")
    public String addPre() {
        String msg = "";
        try {
            userService.updateUser("and FID = 7");
        }catch (Exception e){
            System.out.println(e.getMessage());
        }
        return msg;
    }
}

4、ioc

        配置数据库

import java.sql.SQLException;

import javax.sql.DataSource;

import com.atomikos.icatch.jta.UserTransactionManager;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.*;

import com.atomikos.jdbc.AtomikosDataSourceBean;
import com.microsoft.sqlserver.jdbc.SQLServerXADataSource;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;


@Configuration
@MapperScan(basePackages="com.gloyel.twodbgn.mapper.local",sqlSessionTemplateRef="localSqlSessionTemplate")
public class TestMybatisConfig1 {

    @Primary
    @Bean(name="localDataSource")
    @DependsOn("transactionManager")
    public DataSource testDataSource() throws SQLException {
        SQLServerXADataSource sqlServerXADataSource = new SQLServerXADataSource();
        sqlServerXADataSource.setURL("jdbc:sqlserver://localhost:1433;databaseName=mytest;encrypt=true;trustServerCertificate=true");
        sqlServerXADataSource.setUser("username");
        sqlServerXADataSource.setPassword("password");

        AtomikosDataSourceBean atomikosDataSourceBean = new AtomikosDataSourceBean();
        atomikosDataSourceBean.setXaDataSource(sqlServerXADataSource);
        atomikosDataSourceBean.setUniqueResourceName("localDataSource");

        atomikosDataSourceBean.setMinPoolSize(3);
        atomikosDataSourceBean.setMaxPoolSize(25);

        return atomikosDataSourceBean;
    }
    @Primary
    @Bean(name="localSqlSessionFactory")
    @DependsOn("localDataSource")
    public SqlSessionFactory testSqlSessionFactory(@Qualifier("localDataSource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        return bean.getObject();
    }
    @Primary
    @Bean(name="localSqlSessionTemplate")
    @DependsOn("localSqlSessionFactory")
    public SqlSessionTemplate testSqlSessionTemplate(@Qualifier("localSqlSessionFactory") SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }
}

/***************************************************************************************/

import com.atomikos.icatch.jta.UserTransactionManager;
import com.atomikos.jdbc.AtomikosDataSourceBean;
import com.microsoft.sqlserver.jdbc.SQLServerXADataSource;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
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.context.annotation.DependsOn;
import org.springframework.context.annotation.Lazy;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;

import javax.sql.DataSource;
import javax.transaction.NotSupportedException;
import javax.transaction.SystemException;
import java.sql.SQLException;

@Configuration
@MapperScan(basePackages="com.gloyel.twodbgn.mapper.cloud",sqlSessionTemplateRef="cloudSqlSessionTemplate")
public class TestMybatisConfig2 {

    @Bean(name="cloudDataSource")
    @DependsOn("transactionManager")
    public DataSource testDataSource() throws SQLException {
        SQLServerXADataSource sqlServerXADataSource = new SQLServerXADataSource();
        sqlServerXADataSource.setURL("jdbc:sqlserver://ip:端口;databaseName=mytest;encrypt=true;trustServerCertificate=true");
        sqlServerXADataSource.setUser("username");
        sqlServerXADataSource.setPassword("password");

        AtomikosDataSourceBean atomikosDataSourceBean = new AtomikosDataSourceBean();
        atomikosDataSourceBean.setXaDataSource(sqlServerXADataSource);
        atomikosDataSourceBean.setUniqueResourceName("cloudDataSource");

        atomikosDataSourceBean.setMinPoolSize(3);
        atomikosDataSourceBean.setMaxPoolSize(25);

        return atomikosDataSourceBean;
    }
    @Bean(name="cloudSqlSessionFactory")
    @DependsOn("cloudDataSource")
    public SqlSessionFactory testSqlSessionFactory(@Qualifier("cloudDataSource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        return bean.getObject();
    }
    @Bean(name="cloudSqlSessionTemplate")
    @DependsOn("cloudSqlSessionFactory")
    public SqlSessionTemplate testSqlSessionTemplate(@Qualifier("cloudSqlSessionFactory") SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }
}

5、mapper

@Mapper
public interface UserMapper_C {
    @Select({"select * from User_loginData where 1=1 ${where}"})
    List<User> selectUser(@Param("where")String where);

    @Update({"update Dc_User set FPassWord = 'ccc' where 1=1 ${where}"})
    int updateUser(@Param("where")String where);

}


@Mapper
public interface UserMapper_L {
    @Select({"select * from User_loginData where 1=1 ${where}"})
    List<User> selectUser(@Param("where")String where);

    @Update({"update Dc_User set FPassWord = 'lll' where 1=1 ${where}"})
    int updateUser(@Param("where")String where);

}

6、service

public interface UserService {
    List<User> selectUser(String where);
    int updateUser(String where);
}
@Service("userService")
public class UserServiceImpl implements UserService {
    @Resource
    private UserMapper_L userMapper_l;
    @Resource
    private UserMapper_C userMapper_c;

    @Override
    public List<User> selectUser(String where) {
        return userMapper_c.selectUser(where);
    }

    @Override
    @Transactional
    public int updateUser(String where) {
        int a = userMapper_c.updateUser(where);
//        int c = 1/0;
        int b = userMapper_l.updateUser(where);
        System.out.println("a="+a+" -- b="+b);
        return a+b;
    }
}

五、调试运行

1、运行正常时：

//UserMapper_C 
@Update({"update Dc_User set FPassWord = 'ccc' where 1=1 ${where}"})
int updateUser(@Param("where")String where);

//UserMapper_L
@Update({"update Dc_User set FPassWord = 'lll' where 1=1 ${where}"})
int updateUser(@Param("where")String where);


@Override
    @Transactional
    public int updateUser(String where) {
        int a = userMapper_c.updateUser(where);
//        int c = 1/0;
        int b = userMapper_l.updateUser(where);
        System.out.println("a="+a+" -- b="+b);
        return a+b;
    }

控制台：

云数据库：

本地数据库：

2、运行异常时：

        观察出现异常时，更新语句是否回滚。

//UserMapper_C 
@Update({"update Dc_User set FPassWord = 'ccc000' where 1=1 ${where}"})
int updateUser(@Param("where")String where);

//UserMapper_L
@Update({"update Dc_User set FPassWord = 'lll000' where 1=1 ${where}"})
int updateUser(@Param("where")String where);


@Override
    @Transactional
    public int updateUser(String where) {
        int a = userMapper_c.updateUser(where);
        int c = 1/0;
        int b = userMapper_l.updateUser(where);
        System.out.println("a="+a+" -- b="+b);
        return a+b;
    }

控制台：

云数据库：

本地数据库：

至此，多数据源分布式事务管理项目测试成功！

springboot 分布式事务的解决方案(JTA+Atomic+多数据源)（^_^^_^）
jaryle的专栏
03-18 2万+
首先，到底啥是分布式事务呢，比如我们在执行一个业务逻辑的时候有两步分别操作A数据源和B数据源，当我们在A数据源执行数据更改后，在B数据源执行时出现运行时异常，那么我们必须要让B数据源的操作回滚，并回滚对A数据源的操作；这种情况在支付业务时常常出现；比如买票业务在最后支付失败，那之前的操作必须全部回滚，如果之前的操作分布在多个数据源中，那么这就是典型的分布式事务回滚； 了解了什么是分布式事务，那分...
Springboot Jta Atomikos实现分布式事物管理
p1830095583的博客
04-08 314
这篇文章主要介绍了springboot jta atomikos实现分布式事物管理,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 当项目在连接多个数据库时可能会发生事务问题，即一个库的事务不可能去操作另一个数据库的事务，这时就需要使用atomikos对数据库的事务进行统一的管理 第一步添加atomikos的依赖 <dependency> <groupId>org.springframework.boot</groupId&g
Springboot+Atomikos+Jpa+Mysql实现JTA分布式事务
08-10
myeclipse开发，导入即可用，可以参阅http://www.cnblogs.com/shamo89/p/7326718.html
使用springboot+jta+atomikos配置多数据源事务
12-12
使用springboot+jta+atomikos来配置多数据源下的事务分布管理 里面带有sql语句.直接下载下来,并且运行sql就可以测试运行
SpringBoot事务管理详解：分布式事务解决方案
最新发布
梵心白莲的博客
04-29 921
在现代的软件开发中，事务管理是确保数据一致性和完整性的关键机制。随着微服务架构的广泛应用，分布式系统变得越来越复杂，传统的单机事务管理已经无法满足需求，因此分布式事务管理成为了开发人员必须掌握的技能。Spring Boot作为一款流行的Java开发框架，提供了强大的事务管理功能，本文将详细介绍Spring Boot中的事务管理，特别是分布式事务的解决方案。
【SpringBoot框架篇】4.集成jta-atomikos实现分布式事务
皓亮君的博客
04-25 5475
springboot集成jta-atomikos实现分布式事务简介引入依赖修改配置文件添加配置读取类创建多数据源,管理事务数据持久化数据库DLL文件模拟事务回滚 简介 1.分布式事务 说到分布式事务，可以理解为，由于分布式而引起的事务不一致的问题。随着项目做大，模块拆分，数据库拆分。一次包含增删改操作数据库涉及到了更新两个不同物理节点的数据库，这样的数据库事务只能保证自己处理的部分的事务，但是整个...
springboot-jta-atomikos多数据源事务管理
HongYu012的博客
03-14 1307
背景 我们平时在用springboot开发时，要使用事务，只需要在方法上添加@Transaction注解即可，但这种方式只适用单数据源，在多数据源下就不再适用； 比如在多数据源下，我们在一个方法里执行了数据源A的操作，又执行了数据源B的操作，如果报错了，事务只会回滚主数据源或者是指定事务的数据源数据（@Transactional(value="指定事务")），另一个数据源是不会回滚的； 这种情况下，单纯的@Transactional事务注解是无法实现的，此时就需要用到多数据源事务管理； 以下项目里实
分布式事务-spring_boot_jta_atomikos
会飞的时钟
08-22 561
同一个服务里面多个数据源事务事务一致性
springboot+jta+atomikos
12-28
本项目“springboot+jta+atomikos”旨在利用Spring Boot框架、Java Transaction API (JTA) 和 Atomikos 这一开源事务管理器来实现分布式事务的统一管理。下面将详细阐述这三个关键组件以及它们如何协同工作。 **...
springboot + mybatis + atomikos 多数据源分布式事物管理
05-18
Spring Boot、MyBatis 和 Atomikos 的结合提供了一种解决方案，用于处理多数据源的分布式事务管理。以下是对这个主题的详细阐述。 首先，Spring Boot 是一个基于 Spring 框架的轻量级开发工具，它简化了配置过程并...
SpringBoot+Atomikos分布式事务及多数据源动态切换，两种demo
08-29
在现代企业级应用开发中，分布式事务处理和多数据源管理是常见的需求。Spring Boot作为轻量级的Java开发框架，结合Atomikos这样的分布式事务管理器，可以有效地解决这些问题。本文将深入探讨如何在Spring Boot项目中...
springboot+mybatis+jta+atomikos解决多数据源事务问题.pdf
05-21
本篇文档主要讲述如何使用Spring Boot结合MyBatis、JTA（Java Transaction API）以及Atomikos实现多数据源的事务管理。 ### Spring Boot框架 Spring Boot是Spring家族中的一个全新框架，用于简化新Spring应用的...
spring + JTA + atomikos 实现分布式事务
09-21
spring + JTA + atomikos实现分布式事务， 高大上的技术
Springboot中使用jta+atomikos解决分布式事务
kxj19980524的博客
02-03 4263
如何使用多数据源https://blog.csdn.net/kxj19980524/article/details/86751785 首先分布式事务是基于多数据源的情况下解决在一个方法中调用不同的数据源,如何来进行事务管理的. 在上面那节讲到了多数据源怎么使用事务,可以加注解指定哪个事务就可以了,但是分布式事务的话不可以.因为你一个方法只能有一个事务,方法里有不同的数据源,肯定不能指定某一个事...
springBoot入门总结（八）使用 jta+atomikos 整合springBoot分布式事务
weixin_41557632的博客
02-01 2660
一、JTA：Java Transaction Manager 事务是计算机应用中不可或缺的组件模型，它保证了用户操作的原子性 ( Atomicity )、一致性 ( Consistency )、隔离性 ( Isolation ) 和持久性 ( Durabilily )。 JTA：(Java Transaction Manager)是Java 中对事务进行管理的接口，在Java应用中，调用者实际...
springboot+jta+atomikos分布式多数据源事务管理 (SQLserver)
魑魅魍魉
09-03 1296
在我上一篇博客的项目基础上做更改 springboot多数据源分包式实现 首先我们来试一下没有更改的情况下 @Service public class User2Service { @Autowired private User2Mapper mapper2; @Autowired private User2Mapper mapper1; @Transactional ...
7 -【 SpringBoot 事物管理 】- 分布式事物管理 - springboot + jta + atomikos
何以小城大事的博客
02-23 252
SpringBoot 事物管理 分布式事物管理 - springboot + jta + atomikos
Jta+Atomikos解决分布式事务
dongbeiou的专栏
05-09 665
1.基本概念 1.1 Jta+Atomikos 简介 传统项目中，比如项目中使用到多数据源的时候大多数采用jta+Atomikos解决分布式事务问题，jta+Atomikos底层是基于XA协议的两阶段提交方案。 1.2 XA协议 XA 事务的基础是两阶段提交协议。分为以下两阶段 需要有一个事务协调者来保证所有的事务参与者都完成了准备工作。 如果协调者收到所有参与者都准备好的消息，就会通知所有的事务都可以提交了。 Mysql 在这个XA事务中扮演的是参与者的角色，而不是协调者(事务管理器)。
Springboot整合jta+atomikos解决单jvm多数据源事务问题
u012758488的博客
10-20 286
1、依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-jta-atomikos</artifactId> </dependency> 2、配置 @Configuration // basePackages 最好分开配置 如果放在同一个文件夹可能会报错 @MapperScan(basePac
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值