spring boot+Mybatis+mysql+atomikos+jta实现多数据源分布式事务

最新推荐文章于 2021-01-27 03:28:44 发布
置顶 最新推荐文章于 2021-01-27 03:28:44 发布
阅读量704 收藏
点赞数
分类专栏： Java 文章标签： spring boot Mybatis automatic+jta 分布式事务 多数据源
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangyanORZ/article/details/102697881
版权

spring boot+Mybatis+mysql+atomikos+jta实现多数据源分布式事务

1.导入相关依赖

<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<scope>runtime</scope>
</dependency>
<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>2.0.1</version>
</dependency>
<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-jta-atomikos</artifactId>
</dependency>

2.配置相关application.properties

#第一数据库,主数据源，默认的
spring.datasource.primary.type=com.zaxxer.hikari.HikariDataSource
spring.datasource.primary.url=jdbc:mysql://***.***.***.***:3306/website?useUnicode=true
spring.datasource.primary.username=root
spring.datasource.primary.password=root
spring.datasource.primary.driverClassName=com.mysql.cj.jdbc.MysqlDataSource
spring.datasource.primary.minPoolSize = 3
spring.datasource.primary.maxPoolSize = 25
spring.datasource.primary.maxLifetime = 20000
spring.datasource.primary.borrowConnectionTimeout = 30
spring.datasource.primary.loginTimeout = 30
spring.datasource.primary.maintenanceInterval = 60
spring.datasource.primary.maxIdleTime = 60

#更多数据源
#第二数据库//广告系统
spring.datasource.secondary.type=com.zaxxer.hikari.HikariDataSource
spring.datasource.secondary.url=jdbc:mysql://***.***.***.***:3306/cy_bg3d?useUnicode=true
spring.datasource.secondary.username=root
spring.datasource.secondary.password=root
spring.datasource.primary.driverClassName=com.mysql.cj.jdbc.MysqlDataSource
spring.datasource.secondary.minPoolSize = 3
spring.datasource.secondary.maxPoolSize = 25
spring.datasource.secondary.maxLifetime = 20000
spring.datasource.secondary.borrowConnectionTimeout = 30
spring.datasource.secondary.loginTimeout = 30
spring.datasource.secondary.maintenanceInterval = 60
spring.datasource.secondary.maxIdleTime = 60

#第三数据库//生产管理系统
spring.datasource.thirdly.type=com.zaxxer.hikari.HikariDataSource
spring.datasource.thirdly.url=jdbc:mysql://***.***.***.***:3306/jhz_NewErp?useUnicode=true
spring.datasource.thirdly.username=root
spring.datasource.thirdly.password=root
spring.datasource.primary.driverClassName=com.mysql.cj.jdbc.MysqlDataSource
spring.datasource.thirdly.minPoolSize = 3
spring.datasource.thirdly.maxPoolSize = 25
spring.datasource.thirdly.maxLifetime = 20000
spring.datasource.thirdly.borrowConnectionTimeout = 30
spring.datasource.thirdly.loginTimeout = 30
spring.datasource.thirdly.maintenanceInterval = 60
spring.datasource.thirdly.maxIdleTime = 60

#第四数据库//视频管理系统
spring.datasource.fourthly.type=com.zaxxer.hikari.HikariDataSource
spring.datasource.fourthly.url=jdbc:mysql://***.***.***.***:3306/jhspdb?useUnicode=true
spring.datasource.fourthly.username=root
spring.datasource.fourthly.password=root
spring.datasource.primary.driverClassName=com.mysql.cj.jdbc.MysqlDataSource
spring.datasource.fourthly.minPoolSize = 3
spring.datasource.fourthly.maxPoolSize = 25
spring.datasource.fourthly.maxLifetime = 20000
spring.datasource.fourthly.borrowConnectionTimeout = 30
spring.datasource.fourthly.loginTimeout = 30
spring.datasource.fourthly.maintenanceInterval = 60
spring.datasource.fourthly.maxIdleTime = 60

#下面为连接池的补充设置，应用到上面所有数据源中
#指定连接池最大的连接数，包括使用中的和空闲的连接.
spring.datasource.maximum-pool-size=100
#指定连接池最大的空闲连接数量.
spring.datasource.max-idle=10
#指定连接池等待连接返回的最大等待时间，毫秒单位.
spring.datasource.max-wait=31536000
#指定必须保持连接的最小值(For DBCP and Tomcat connection pools)
spring.datasource.min-idle=5
#指定启动连接池时，初始建立的连接数量
spring.datasource.initial-size=5 
#指定获取连接时连接校验的sql查询语句.
spring.datasource.validation-query=SELECT 1
#当从连接池借用连接时，是否测试该连接.
spring.datasource.test-on-borrow=false
#当连接空闲时，是否执行连接测试.
spring.datasource.test-while-idle=true
#指定空闲连接检查、废弃连接清理、空闲连接池大小调整之间的操作时间间隔
spring.datasource.time-between-eviction-runs-millis=18800

3.创建配置文件

package com.JHZ.website.config.datasource3;

import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(prefix = "spring.datasource.primary")
public class DBConfig1 {
    private String url;
    private String username;
    private String password;
    private int minPoolSize;
    private int maxPoolSize;
    private int maxLifetime;
    private int borrowConnectionTimeout;
    private int loginTimeout;
    private int maintenanceInterval;
    private int maxIdleTime;
    private String testQuery;
	public String getUrl() {
		return url;
	}
	public void setUrl(String url) {
		this.url = url;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public int getMinPoolSize() {
		return minPoolSize;
	}
	public void setMinPoolSize(int minPoolSize) {
		this.minPoolSize = minPoolSize;
	}
	public int getMaxPoolSize() {
		return maxPoolSize;
	}
	public void setMaxPoolSize(int maxPoolSize) {
		this.maxPoolSize = maxPoolSize;
	}
	public int getMaxLifetime() {
		return maxLifetime;
	}
	public void setMaxLifetime(int maxLifetime) {
		this.maxLifetime = maxLifetime;
	}
	public int getBorrowConnectionTimeout() {
		return borrowConnectionTimeout;
	}
	public void setBorrowConnectionTimeout(int borrowConnectionTimeout) {
		this.borrowConnectionTimeout = borrowConnectionTimeout;
	}
	public int getLoginTimeout() {
		return loginTimeout;
	}
	public void setLoginTimeout(int loginTimeout) {
		this.loginTimeout = loginTimeout;
	}
	public int getMaintenanceInterval() {
		return maintenanceInterval;
	}
	public void setMaintenanceInterval(int maintenanceInterval) {
		this.maintenanceInterval = maintenanceInterval;
	}
	public int getMaxIdleTime() {
		return maxIdleTime;
	}
	public void setMaxIdleTime(int maxIdleTime) {
		this.maxIdleTime = maxIdleTime;
	}
	public String getTestQuery() {
		return testQuery;
	}
	public void setTestQuery(String testQuery) {
		this.testQuery = testQuery;
	}
}

package com.JHZ.website.config.datasource3;

import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(prefix = "spring.datasource.secondary")
public class DBConfig2 {
    private String url;
    private String username;
    private String password;
    private int minPoolSize;
    private int maxPoolSize;
    private int maxLifetime;
    private int borrowConnectionTimeout;
    private int loginTimeout;
    private int maintenanceInterval;
    private int maxIdleTime;
    private String testQuery;
	public String getUrl() {
		return url;
	}
	public void setUrl(String url) {
		this.url = url;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public int getMinPoolSize() {
		return minPoolSize;
	}
	public void setMinPoolSize(int minPoolSize) {
		this.minPoolSize = minPoolSize;
	}
	public int getMaxPoolSize() {
		return maxPoolSize;
	}
	public void setMaxPoolSize(int maxPoolSize) {
		this.maxPoolSize = maxPoolSize;
	}
	public int getMaxLifetime() {
		return maxLifetime;
	}
	public void setMaxLifetime(int maxLifetime) {
		this.maxLifetime = maxLifetime;
	}
	public int getBorrowConnectionTimeout() {
		return borrowConnectionTimeout;
	}
	public void setBorrowConnectionTimeout(int borrowConnectionTimeout) {
		this.borrowConnectionTimeout = borrowConnectionTimeout;
	}
	public int getLoginTimeout() {
		return loginTimeout;
	}
	public void setLoginTimeout(int loginTimeout) {
		this.loginTimeout = loginTimeout;
	}
	public int getMaintenanceInterval() {
		return maintenanceInterval;
	}
	public void setMaintenanceInterval(int maintenanceInterval) {
		this.maintenanceInterval = maintenanceInterval;
	}
	public int getMaxIdleTime() {
		return maxIdleTime;
	}
	public void setMaxIdleTime(int maxIdleTime) {
		this.maxIdleTime = maxIdleTime;
	}
	public String getTestQuery() {
		return testQuery;
	}
	public void setTestQuery(String testQuery) {
		this.testQuery = testQuery;
	}
}

package com.JHZ.website.config.datasource3;

import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(prefix = "spring.datasource.thirdly")
public class DBConfig3 {
    private String url;
    private String username;
    private String password;
    private int minPoolSize;
    private int maxPoolSize;
    private int maxLifetime;
    private int borrowConnectionTimeout;
    private int loginTimeout;
    private int maintenanceInterval;
    private int maxIdleTime;
    private String testQuery;
	public String getUrl() {
		return url;
	}
	public void setUrl(String url) {
		this.url = url;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public int getMinPoolSize() {
		return minPoolSize;
	}
	public void setMinPoolSize(int minPoolSize) {
		this.minPoolSize = minPoolSize;
	}
	public int getMaxPoolSize() {
		return maxPoolSize;
	}
	public void setMaxPoolSize(int maxPoolSize) {
		this.maxPoolSize = maxPoolSize;
	}
	public int getMaxLifetime() {
		return maxLifetime;
	}
	public void setMaxLifetime(int maxLifetime) {
		this.maxLifetime = maxLifetime;
	}
	public int getBorrowConnectionTimeout() {
		return borrowConnectionTimeout;
	}
	public void setBorrowConnectionTimeout(int borrowConnectionTimeout) {
		this.borrowConnectionTimeout = borrowConnectionTimeout;
	}
	public int getLoginTimeout() {
		return loginTimeout;
	}
	public void setLoginTimeout(int loginTimeout) {
		this.loginTimeout = loginTimeout;
	}
	public int getMaintenanceInterval() {
		return maintenanceInterval;
	}
	public void setMaintenanceInterval(int maintenanceInterval) {
		this.maintenanceInterval = maintenanceInterval;
	}
	public int getMaxIdleTime() {
		return maxIdleTime;
	}
	public void setMaxIdleTime(int maxIdleTime) {
		this.maxIdleTime = maxIdleTime;
	}
	public String getTestQuery() {
		return testQuery;
	}
	public void setTestQuery(String testQuery) {
		this.testQuery = testQuery;
	}
    
}

package com.JHZ.website.config.datasource3;

import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(prefix = "spring.datasource.fourthly")
public class DBConfig4 {
    private String url;
    private String username;
    private String password;
    private int minPoolSize;
    private int maxPoolSize;
    private int maxLifetime;
    private int borrowConnectionTimeout;
    private int loginTimeout;
    private int maintenanceInterval;
    private int maxIdleTime;
    private String testQuery;
	public String getUrl() {
		return url;
	}
	public void setUrl(String url) {
		this.url = url;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public int getMinPoolSize() {
		return minPoolSize;
	}
	public void setMinPoolSize(int minPoolSize) {
		this.minPoolSize = minPoolSize;
	}
	public int getMaxPoolSize() {
		return maxPoolSize;
	}
	public void setMaxPoolSize(int maxPoolSize) {
		this.maxPoolSize = maxPoolSize;
	}
	public int getMaxLifetime() {
		return maxLifetime;
	}
	public void setMaxLifetime(int maxLifetime) {
		this.maxLifetime = maxLifetime;
	}
	public int getBorrowConnectionTimeout() {
		return borrowConnectionTimeout;
	}
	public void setBorrowConnectionTimeout(int borrowConnectionTimeout) {
		this.borrowConnectionTimeout = borrowConnectionTimeout;
	}
	public int getLoginTimeout() {
		return loginTimeout;
	}
	public void setLoginTimeout(int loginTimeout) {
		this.loginTimeout = loginTimeout;
	}
	public int getMaintenanceInterval() {
		return maintenanceInterval;
	}
	public void setMaintenanceInterval(int maintenanceInterval) {
		this.maintenanceInterval = maintenanceInterval;
	}
	public int getMaxIdleTime() {
		return maxIdleTime;
	}
	public void setMaxIdleTime(int maxIdleTime) {
		this.maxIdleTime = maxIdleTime;
	}
	public String getTestQuery() {
		return testQuery;
	}
	public void setTestQuery(String testQuery) {
		this.testQuery = testQuery;
	}
}

4.创建数据源bean

数据源primary

package com.JHZ.website.config.datasource3;

import java.sql.SQLException;
import javax.sql.DataSource;
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.boot.context.properties.ConfigurationProperties;
import com.atomikos.jdbc.AtomikosDataSourceBean;
import com.mysql.jdbc.jdbc2.optional.MysqlXADataSource;
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;

@Configuration
@MapperScan(basePackages = "com.JHZ.website.mapper", sqlSessionFactoryRef = "test1SqlSessionFactory", sqlSessionTemplateRef = "test1SqlSessionTemplate")
public class MybatisDbOneConfig {

	// 将这个对象放入Spring容器中
	@Bean(name = "test1DataSource")
	@Primary
	@ConfigurationProperties(prefix = "spring.datasource.primary")
	public DataSource getDateSource1(DBConfig1 testConfig) throws SQLException {

		MysqlXADataSource mysqlXaDataSource = new MysqlXADataSource();
		mysqlXaDataSource.setUrl(testConfig.getUrl());
		mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);
		mysqlXaDataSource.setPassword(testConfig.getPassword());
		mysqlXaDataSource.setUser(testConfig.getUsername());

		AtomikosDataSourceBean xaDataSource = new AtomikosDataSourceBean();
		xaDataSource.setXaDataSource(mysqlXaDataSource);
		xaDataSource.setUniqueResourceName("test1DataSource");
		xaDataSource.setMinPoolSize(testConfig.getMinPoolSize());
		xaDataSource.setMaxPoolSize(testConfig.getMaxPoolSize());
		xaDataSource.setMaxLifetime(testConfig.getMaxLifetime());
		xaDataSource.setBorrowConnectionTimeout(testConfig.getBorrowConnectionTimeout());
		xaDataSource.setLoginTimeout(testConfig.getLoginTimeout());
		xaDataSource.setMaintenanceInterval(testConfig.getMaintenanceInterval());
		xaDataSource.setMaxIdleTime(testConfig.getMaxIdleTime());
		xaDataSource.setTestQuery(testConfig.getTestQuery());

		return xaDataSource;
	}

	@Bean(name = "test1SqlSessionFactory")
	@Primary
	// @Qualifier表示查找Spring容器中名字为test1DataSource的对象
	public SqlSessionFactory test1SqlSessionFactory(@Qualifier("test1DataSource") DataSource datasource)
			throws Exception {
		SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
		bean.setDataSource(datasource);
		bean.setMapperLocations(
				new PathMatchingResourcePatternResolver().getResources("classpath*:mappers/datasource1/*.xml"));
		return bean.getObject();
	}

	@Bean(name = "test1SqlSessionTemplate")
	@Primary
	public SqlSessionTemplate test1sqlsessiontemplate(
			@Qualifier("test1SqlSessionFactory") SqlSessionFactory sessionfactory) {
		return new SqlSessionTemplate(sessionfactory);
	}

}

数据源secondary

package com.JHZ.website.config.datasource3;

import java.sql.SQLException;
import javax.sql.DataSource;
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.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import com.atomikos.jdbc.AtomikosDataSourceBean;
import com.mysql.jdbc.jdbc2.optional.MysqlXADataSource;

@Configuration
@MapperScan(basePackages = "com.JHZ.website.twomapper", sqlSessionFactoryRef = "test2SqlSessionFactory", sqlSessionTemplateRef = "test2SqlSessionTemplate")
public class MybatisDbTwoConfig {
	@Bean(name = "test2DataSource")
	@ConfigurationProperties(prefix = "spring.datasource.secondary")
	public DataSource getDateSource2(DBConfig2 testConfig) throws SQLException {

		MysqlXADataSource mysqlXaDataSource = new MysqlXADataSource();
		mysqlXaDataSource.setUrl(testConfig.getUrl());
		mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);
		mysqlXaDataSource.setPassword(testConfig.getPassword());
		mysqlXaDataSource.setUser(testConfig.getUsername());

		AtomikosDataSourceBean xaDataSource = new AtomikosDataSourceBean();
		xaDataSource.setXaDataSource(mysqlXaDataSource);
		xaDataSource.setUniqueResourceName("test2DataSource");
		xaDataSource.setMinPoolSize(testConfig.getMinPoolSize());
		xaDataSource.setMaxPoolSize(testConfig.getMaxPoolSize());
		xaDataSource.setMaxLifetime(testConfig.getMaxLifetime());
		xaDataSource.setBorrowConnectionTimeout(testConfig.getBorrowConnectionTimeout());
		xaDataSource.setLoginTimeout(testConfig.getLoginTimeout());
		xaDataSource.setMaintenanceInterval(testConfig.getMaintenanceInterval());
		xaDataSource.setMaxIdleTime(testConfig.getMaxIdleTime());
		xaDataSource.setTestQuery(testConfig.getTestQuery());

		return xaDataSource;
		// return DataSourceBuilder.create().build();
	}

	@Bean(name = "test2SqlSessionFactory")
	public SqlSessionFactory test2SqlSessionFactory(@Qualifier("test2DataSource") DataSource datasource)
			throws Exception {
		SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
		bean.setDataSource(datasource);
		bean.setMapperLocations(
				new PathMatchingResourcePatternResolver().getResources("classpath*:mappers/datasource2/*.xml"));
		return bean.getObject();
	}

	@Bean(name = "test2SqlSessionTemplate")
	public SqlSessionTemplate test2sqlsessiontemplate(
			@Qualifier("test2SqlSessionFactory") SqlSessionFactory sessionfactory) {
		return new SqlSessionTemplate(sessionfactory);
	}
}

数据源thirdly

package com.JHZ.website.config.datasource3;

import java.sql.SQLException;
import javax.sql.DataSource;
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.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import com.atomikos.jdbc.AtomikosDataSourceBean;
import com.mysql.jdbc.jdbc2.optional.MysqlXADataSource;

@Configuration
@MapperScan(basePackages = "com.JHZ.website.threemapper", sqlSessionFactoryRef = "test3SqlSessionFactory", sqlSessionTemplateRef = "test3SqlSessionTemplate")
public class MybatisDbThreeConfig {
	@Bean(name = "test3DataSource")
	@ConfigurationProperties(prefix = "spring.datasource.thirdly")
	public DataSource getDateSource3(DBConfig3 testConfig) throws SQLException {

		MysqlXADataSource mysqlXaDataSource = new MysqlXADataSource();
		mysqlXaDataSource.setUrl(testConfig.getUrl());
		mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);
		mysqlXaDataSource.setPassword(testConfig.getPassword());
		mysqlXaDataSource.setUser(testConfig.getUsername());

		AtomikosDataSourceBean xaDataSource = new AtomikosDataSourceBean();
		xaDataSource.setXaDataSource(mysqlXaDataSource);
		xaDataSource.setUniqueResourceName("test3DataSource");
		xaDataSource.setMinPoolSize(testConfig.getMinPoolSize());
		xaDataSource.setMaxPoolSize(testConfig.getMaxPoolSize());
		xaDataSource.setMaxLifetime(testConfig.getMaxLifetime());
		xaDataSource.setBorrowConnectionTimeout(testConfig.getBorrowConnectionTimeout());
		xaDataSource.setLoginTimeout(testConfig.getLoginTimeout());
		xaDataSource.setMaintenanceInterval(testConfig.getMaintenanceInterval());
		xaDataSource.setMaxIdleTime(testConfig.getMaxIdleTime());
		xaDataSource.setTestQuery(testConfig.getTestQuery());

		return xaDataSource;
		// return DataSourceBuilder.create().build();
	}

	@Bean(name = "test3SqlSessionFactory")
	public SqlSessionFactory test3SqlSessionFactory(@Qualifier("test3DataSource") DataSource datasource)
			throws Exception {
		SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
		bean.setDataSource(datasource);
		bean.setMapperLocations(
				new PathMatchingResourcePatternResolver().getResources("classpath*:mappers/datasource3/*.xml"));
		return bean.getObject();
	}

	@Bean(name = "test3SqlSessionTemplate")
	public SqlSessionTemplate test3sqlsessiontemplate(
			@Qualifier("test3SqlSessionFactory") SqlSessionFactory sessionfactory) {
		return new SqlSessionTemplate(sessionfactory);
	}
}

数据源fourthly

package com.JHZ.website.config.datasource3;

import java.sql.SQLException;
import javax.sql.DataSource;
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.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import com.atomikos.jdbc.AtomikosDataSourceBean;
import com.mysql.jdbc.jdbc2.optional.MysqlXADataSource;

@Configuration
@MapperScan(basePackages = "com.JHZ.website.fourmapper", sqlSessionFactoryRef = "test4SqlSessionFactory", sqlSessionTemplateRef = "test4SqlSessionTemplate")
public class MybatisDbFourthlyConfig {
	@Bean(name = "test4DataSource")
	@ConfigurationProperties(prefix = "spring.datasource.fourthly")
	public DataSource getDateSource4(DBConfig4 testConfig) throws SQLException {

		MysqlXADataSource mysqlXaDataSource = new MysqlXADataSource();
		mysqlXaDataSource.setUrl(testConfig.getUrl());
		mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);
		mysqlXaDataSource.setPassword(testConfig.getPassword());
		mysqlXaDataSource.setUser(testConfig.getUsername());

		AtomikosDataSourceBean xaDataSource = new AtomikosDataSourceBean();
		xaDataSource.setXaDataSource(mysqlXaDataSource);
		xaDataSource.setUniqueResourceName("test4DataSource");
		xaDataSource.setMinPoolSize(testConfig.getMinPoolSize());
		xaDataSource.setMaxPoolSize(testConfig.getMaxPoolSize());
		xaDataSource.setMaxLifetime(testConfig.getMaxLifetime());
		xaDataSource.setBorrowConnectionTimeout(testConfig.getBorrowConnectionTimeout());
		xaDataSource.setLoginTimeout(testConfig.getLoginTimeout());
		xaDataSource.setMaintenanceInterval(testConfig.getMaintenanceInterval());
		xaDataSource.setMaxIdleTime(testConfig.getMaxIdleTime());
		xaDataSource.setTestQuery(testConfig.getTestQuery());

		return xaDataSource;
		// return DataSourceBuilder.create().build();
	}

	@Bean(name = "test4SqlSessionFactory")
	public SqlSessionFactory test4SqlSessionFactory(@Qualifier("test4DataSource") DataSource datasource)
			throws Exception {
		SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
		bean.setDataSource(datasource);
		bean.setMapperLocations(
				new PathMatchingResourcePatternResolver().getResources("classpath*:mappers/datasource4/*.xml"));
		return bean.getObject();
	}

	@Bean(name = "test4SqlSessionTemplate")
	public SqlSessionTemplate test4sqlsessiontemplate(
			@Qualifier("test4SqlSessionFactory") SqlSessionFactory sessionfactory) {
		return new SqlSessionTemplate(sessionfactory);
	}
}

5.创建事务管理器

package com.JHZ.website.config.datasource3;

import javax.transaction.TransactionManager;
import javax.transaction.UserTransaction;
import org.springframework.context.annotation.Bean;
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;

public class TransactionManagerConfig {
	/**
	 * 自定义事务 MyBatis自动参与到spring事务管理中，无需额外配置，
	 * 只要org.mybatis.spring.SqlSessionFactoryBean
	 * 引用的数据源与DataSourceTransactionManager引用的数据源一致即可，否则事务管理会不起作用。
	 */
	@Bean(name = "userTransaction")
	public UserTransaction userTransaction() throws Throwable {
		UserTransactionImp userTransactionImp = new UserTransactionImp();
		userTransactionImp.setTransactionTimeout(10000);
		return userTransactionImp;
	}

	@Bean(name = "atomikosTransactionManager", initMethod = "init", destroyMethod = "close")
	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();
		JtaTransactionManager manager = new JtaTransactionManager(userTransaction, atomikosTransactionManager());
		return manager;
	}
}

6.添加service进行事务控制业务

@Transactional(value="transactionManager")
	@Override
	public Integer demo(Integer a, Integer b) {
		System.err.println(a+"："+b);
		Integer row1 = userMapper.insertDemo(a,b);
		Integer row2 = twoMapper.insertDemo(a,b);
		Integer row3 = 0;
		Integer row4 = 0;
		if(a/b>1) {
			row3 = threeMapper.insertDemo(a,b);
			row4 = fourMapper.insertDemo(a,b);
		}
		return row1+row2+row3+row4;
	}

7.创建controller进行访问测试

@PostMapping("demo.do")
	public Integer demo(Integer a, Integer b) throws Exception {
		System.err.println("user controller editManager's user:"+a+b);
		return userService.demo(a,b);
	}

当b=0时报错四个数据库都没有插入数据

yangyanORZ
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[springboot一本通]-4.12.1.mybatis+atomikos实现分布式事务
字母哥博客
02-27 969
两个数据源的名称分别是：primary和secondary。分别访问testdb和testdb2数据库。另外注意：驱动类是MysqlXADataSource（支持分布式事务），而不是MysqlDataSource。
Spring+MyBatis+Atomikos实现JTA分布式事务
08-13
NULL 博文链接：https://injavawetrust.iteye.com/blog/2308552
SpringBoot+Mybatis+atomikos实现分布式事务
酷爱编程的小猿同学
12-23 1037
背景：随着业务的不断发展，数据量的倍增，单个数据库的性能产生瓶颈，我们可能会对数据库进行分区（也就是我们常说的分库分表），这里所说的分区指的是物理分区，分区之后可能不同的库就处于不同的服务器上了，这个时候单个数据库的ACID已经不能适应这种情况了，而在这种ACID的集群环境下，再想保证集群的ACID几乎是很难达到，或者即使能达到那么效率和性能会大幅下降，这个时候我们就会用到分布式事务 Atomikos 是干嘛用的？ Atomikos 是一个为Java平台提供增值服务的并且开源类事务管理器，主要用于处理.
Spring MyBatis Atomikos 实现JTA分布式事务
热门推荐
07-01 2万+
Spring+MyBatis+Atomikos实现JTA分布式事务 项目中需要同时操作两个数据库，对两个数据库中的表同时做变更时就需要控制事务，要么全部成功，要么全部失败。 Atomikos是一个开源的事务管理器，研究了一下，可以满足需求。 理解分布式事务JTA原理参见:http://www.ibm.com/developerworks/......
Spring+Mybatis+Atomikos实现JAVA初始化并控制多个数据源+分布式事务
07-27
Spring+Mybatis+Atomikos实现JAVA初始化并控制多个数据源+分布式事务的一个DEMO，内涵源代码，以及一篇关于该内容的博客
Spring boot+Atomikos+JTA+Hibernate+mybatis+MySQL实现分布式事务+多数据源
10-08
本案例主要探讨如何利用Spring Boot、Atomikos、JTA（Java Transaction API）、Hibernate以及MyBatis，结合MySQL数据库，实现一个跨数据源的分布式事务解决方案。 首先，Spring Boot是一个基于Spring框架的快速开发...
Spring Boot + Druid + Mybatis + Atomikos 配置多数据源 并支持分布式事务
01-23
本教程将探讨如何利用Spring Boot、Druid、Mybatis以及Atomikos来配置多数据源并实现分布式事务。 首先，Spring Boot是Java生态系统中的一个流行框架，它简化了设置和配置过程，使得开发人员可以快速启动新项目。在...
详解Spring Boot + Mybatis 实现动态数据源
08-26
Spring Boot + Mybatis 实现动态数据源 动态数据源是指在实际应用中根据不同的场景和需求动态切换数据源的技术，例如在多租户场景中，每个用户对应不同的数据库，系统登录时需要根据用户信息切换到用户对应的数据库...
java+spring+mybatis+mysql+RuoYi-atomikos-实现分布式事务.zip
11-09
本项目"java+spring+mybatis+mysql+RuoYi-atomikos-实现分布式事务.zip"是一个基于若依（RuoYi）框架改造的多模块分布式事务解决方案，它利用了Atomikos这一强大的分布式事务管理器。以下将详细解析这个项目的知识点...
Spring Boot + Mybatis 实现动态数据源案例分析
08-26
该案例包括创建多个数据源、配置数据源信息、实现数据源切换逻辑等步骤。 结论 动态数据源是当前应用程序中非常重要的一项功能，Spring Boot 和 Mybatis 的结合可以实现动态数据源的功能。本文提供了一个基于 ...
spring+mybatis+jta实现多数据源的分布式事物（代码可以直接运行）
06-15
使用jta来管理多数据源的事物，代码整洁，一看就懂
Springboot+Atomikos+Jpa+Mysql实现JTA分布式事务
08-10
myeclipse开发，导入即可用，可以参阅http://www.cnblogs.com/shamo89/p/7326718.html
jta:Springboot + Atomikos + Druid + Mysql 实现JTA分布式事务
05-17
jta Springboot + Atomikos + Druid + Mysql 实现JTA分布式事务 问题一：Druid 和 Mysql 版本的问题 问题二：Springtest 默认情况下事务回滚 Mysql对XA协议支持不好，有待看
记录学习的点滴（Spring+Mybatis+Atomikos+Tomcat实现分布式事务管理）
Chuan-Ge的博客
12-22 1960
当更新的多个表不在同一数据库的时候，但是它们又必须在同一事务内，这个时候分布式事务就派上用场啦。
多库数据源深入分析（Mybatis+ Spring + JTA）
happyzwh的专栏
05-08 4136
最近搭建架构，碰到JTA和事务Transaction的问题，在此做个总结：   架构：Mybatis+ Spring   技术：spring的AbstractRoutingDataSource和JTA   老规矩，先贴代码，在讲原理，刚开始的时候不使用JTA，代码如下：     Java代码   /** * DataSource上下文句柄，通过此类设置需要访问的
Spring Boot入门样例-154-mybatis-atomikos整合Atomikos和Mybatis处理多数据库分布式事务
花生——宁静致远
11-27 381
Spring Boot入门样例-154-mybatis-atomikos整合Atomikos和Mybatis处理多数据库分布式事务 比如用户下单成功，必须扣减用户的余额，此时两个库的数据需要同时成功或者同时失败。本demo演示如何使用mybatis整合Atomikos进行多数据库分布式事务操作 前言 本Spring Boot入门样例准备工作参考： Spring Boot入门样例-001-Ja...
【Spring实战】springboot+Atomikos+mybatis+mysql 实现分布式事务
qq_34125999的博客
03-03 4060
1 环境 (1) 数据库 CREATE TABLE `t_student` ( `n_id` int(11) NOT NULL AUTO_INCREMENT, `c_name` varchar(255) DEFAULT NULL, `c_age` int(12) DEFAULT NULL, PRIMARY KEY (`n_id`) USING BTREE ) ENGINE=I...
【分布式】springboot + mybatis + JTA + Atomikos 实现多数据源的分布式事务管理
王如霜
05-24 3093
文章目录1. 添加依赖(pom.xml)2. 配置数据库连接信息 （application.yml）3. 读取配置文件信息4. 创建多数据源5. 启动项添加@EnableConfigurationProperties6. 测试使用事务注解 spring boot默认继承事务，只要在方法上添加@Transaction注解即可， 但是这种只适用与单数据源，在多数据源下就不再适用，比如在一个servic...
jta mysql_Springboot + Atomikos + Druid + Mysql 实现JTA分布式事务
weixin_35215225的博客
01-27 136
DataSource 配置1 packagecom.cheng.dynamic.config;23 importjava.util.Properties;45 importjavax.sql.DataSource;67 importorg.springframework.beans.factory.annotation.Autowired;8 importorg.springframework.b...
layui+spring boot+mybatis+mysql
最新发布
10-02
layui提供了丰富的前端UI组件和交互功能，Spring Boot可以简化后端业务逻辑的开发，MyBatis可以实现数据库操作的分离和优化，而MySQL可以提供稳定和高性能的数据库服务。这样的组合可以大大提高开发效率和系统性能，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值