springboot整合多数据源及传统的分布式事务解决方法jta-atomikos

最新推荐文章于 2021-02-06 10:02:29 发布
最新推荐文章于 2021-02-06 10:02:29 发布
阅读量254 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Leon_Jinhai_Sun/article/details/101366104
版权 
<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>com.learn</groupId>
	<artifactId>springboot_mybatis01</artifactId>
	<version>0.0.1-SNAPSHOT</version>

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.12.RELEASE</version>
	</parent>
	
	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.8</java.version>
		<thymeleaf.version>3.0.9.RELEASE</thymeleaf.version>
		<thymeleaf-layout-dialect.version>2.2.2</thymeleaf-layout-dialect.version>
	</properties>
	
	<dependencies>
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
		</dependency>
		<dependency>
			<!-- 引入web模块 -->
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<!-- Spring Boot进行单元测试的模块 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
		</dependency>
		<!-- <dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-jdbc</artifactId>
		</dependency> -->	
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
		</dependency>
		<!-- 引入druid数据源 -->
		<!-- <dependency>
		    <groupId>com.alibaba</groupId>
		    <artifactId>druid</artifactId>
		    <version>1.1.8</version>
		</dependency> -->
		<dependency>  
		    <groupId>org.mybatis.spring.boot</groupId>  
		    <artifactId>mybatis-spring-boot-starter</artifactId>  
		    <version>1.3.2</version>  
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-jta-atomikos</artifactId>
		</dependency>
	</dependencies>
	
	<!-- 这个插件,可以将应用打包成一个可执行的jar包 -->
	<build>
	    <plugins>
	        <plugin>
	            <groupId>org.springframework.boot</groupId>
	            <artifactId>spring-boot-maven-plugin</artifactId>
	        </plugin>
	    </plugins>
	</build>
	

</project>
#debug=true
#server.port=7900

#server.context-path=/boot02

logging.level.com.learn=trace
#logging.file=D:/springboot.log
logging.file=springboot.log
logging.pattern.console=%d{yyyy-MM-dd} [%thread] %-5level %logger{50} - %msg%n
logging.pattern.file=%d{yyyy-MM-dd} ==== [%thread] %-5level ==== %logger{50} ==== %msg%n
#spring.resources.static-locations=classpath:/hello,classpath:/learn

#mybatis.config-location=classpath:mybatis/mybatis-config.xml
#mybatis.mapper-locations=classpath:mybatis/mapper/*.xml

spring.application.name=springboot_mybatis

# Mysql 1
mysql.datasource.test1.url = jdbc:mysql://localhost:3306/test01?useSSL=false&useUnicode=true&characterEncoding=UTF-8
mysql.datasource.test1.username = root
mysql.datasource.test1.password = 123456

mysql.datasource.test1.minPoolSize = 3
mysql.datasource.test1.maxPoolSize = 25
mysql.datasource.test1.maxLifetime = 20000
mysql.datasource.test1.borrowConnectionTimeout = 30
mysql.datasource.test1.loginTimeout = 30
mysql.datasource.test1.maintenanceInterval = 60
mysql.datasource.test1.maxIdleTime = 60



# Mysql 2
mysql.datasource.test2.url =jdbc:mysql://localhost:3306/test02?useSSL=false&useUnicode=true&characterEncoding=UTF-8
mysql.datasource.test2.username =root
mysql.datasource.test2.password =123456

mysql.datasource.test2.minPoolSize = 3
mysql.datasource.test2.maxPoolSize = 25
mysql.datasource.test2.maxLifetime = 20000
mysql.datasource.test2.borrowConnectionTimeout = 30
mysql.datasource.test2.loginTimeout = 30
mysql.datasource.test2.maintenanceInterval = 60
mysql.datasource.test2.maxIdleTime = 60


package com.learn.cloud.datasource;

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

//@Data
@ConfigurationProperties(prefix = "mysql.datasource.test1")
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;
	}
	@Override
	public String toString() {
		return "DBConfig1 [url=" + url + ", username=" + username + ", password=" + password + ", minPoolSize="
				+ minPoolSize + ", maxPoolSize=" + maxPoolSize + ", maxLifetime=" + maxLifetime
				+ ", borrowConnectionTimeout=" + borrowConnectionTimeout + ", loginTimeout=" + loginTimeout
				+ ", maintenanceInterval=" + maintenanceInterval + ", maxIdleTime=" + maxIdleTime + ", testQuery="
				+ testQuery + "]";
	}
}


package com.learn.cloud.datasource;

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

//@Data
@ConfigurationProperties(prefix = "mysql.datasource.test2")
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;
	}
	@Override
	public String toString() {
		return "DBConfig2 [url=" + url + ", username=" + username + ", password=" + password + ", minPoolSize="
				+ minPoolSize + ", maxPoolSize=" + maxPoolSize + ", maxLifetime=" + maxLifetime
				+ ", borrowConnectionTimeout=" + borrowConnectionTimeout + ", loginTimeout=" + loginTimeout
				+ ", maintenanceInterval=" + maintenanceInterval + ", maxIdleTime=" + maxIdleTime + ", testQuery="
				+ testQuery + "]";
	}
}


package com.learn.cloud.datasource;

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.jta.atomikos.AtomikosDataSourceBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

import com.mysql.jdbc.jdbc2.optional.MysqlXADataSource;

@Configuration
//basePackages 最好分开配置 如果放在同一个文件夹可能会报错
@MapperScan(basePackages = "com.learn.cloud.test01", sqlSessionTemplateRef = "testSqlSessionTemplate")
public class MyBatisConfig1 {

	// 配置数据源
	@Primary
	@Bean(name = "testDataSource")
	public DataSource testDataSource(DBConfig1 testConfig) throws SQLException {
		MysqlXADataSource mysqlXaDataSource = new MysqlXADataSource();
		mysqlXaDataSource.setUrl(testConfig.getUrl());
		mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);
		mysqlXaDataSource.setPassword(testConfig.getPassword());
		mysqlXaDataSource.setUser(testConfig.getUsername());
		mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);

		AtomikosDataSourceBean xaDataSource = new AtomikosDataSourceBean();
		xaDataSource.setXaDataSource(mysqlXaDataSource);
		xaDataSource.setUniqueResourceName("testDataSource");

		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;
	}

	@Primary
	@Bean(name = "testSqlSessionFactory")
	public SqlSessionFactory testSqlSessionFactory(@Qualifier("testDataSource") DataSource dataSource)
			throws Exception {
		SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
		bean.setDataSource(dataSource);
		return bean.getObject();
	}

	@Primary
	@Bean(name = "testSqlSessionTemplate")
	public SqlSessionTemplate testSqlSessionTemplate(
			@Qualifier("testSqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
		return new SqlSessionTemplate(sqlSessionFactory);
	}
}


package com.learn.cloud.datasource;

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.jta.atomikos.AtomikosDataSourceBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.mysql.jdbc.jdbc2.optional.MysqlXADataSource;

@Configuration
@MapperScan(basePackages = "com.learn.cloud.test02", sqlSessionTemplateRef = "test2SqlSessionTemplate")
public class MyBatisConfig2 {

	// 配置数据源
	@Bean(name = "test2DataSource")
	public DataSource testDataSource(DBConfig2 testConfig) throws SQLException {
		MysqlXADataSource mysqlXaDataSource = new MysqlXADataSource();
		mysqlXaDataSource.setUrl(testConfig.getUrl());
		mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);
		mysqlXaDataSource.setPassword(testConfig.getPassword());
		mysqlXaDataSource.setUser(testConfig.getUsername());
		mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);

		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;
	}

	@Bean(name = "test2SqlSessionFactory")
	public SqlSessionFactory testSqlSessionFactory(@Qualifier("test2DataSource") DataSource dataSource)
			throws Exception {
		SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
		bean.setDataSource(dataSource);
		return bean.getObject();
	}

	@Bean(name = "test2SqlSessionTemplate")
	public SqlSessionTemplate testSqlSessionTemplate(
			@Qualifier("test2SqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
		return new SqlSessionTemplate(sqlSessionFactory);
	}
}


package com.learn.cloud.entity;

public class User {
	

	  private Long id;
	
	  private String username;
	
	  private String password;
	
	  private String openid;
	  
	  private Integer role;

		public Long getId() {
			return id;
		}
		
		public void setId(Long id) {
			this.id = id;
		}
		
		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 String getOpenid() {
			return openid;
		}
		
		public void setOpenid(String openid) {
			this.openid = openid;
		}
		
		public Integer getRole() {
			return role;
		}
		
		public void setRole(Integer role) {
			this.role = role;
		}

		@Override
		public String toString() {
			return "User [id=" + id + ", username=" + username + ", password=" + password + ", openid=" + openid
					+ ", role=" + role + "]";
		}

}

package com.learn.cloud.test01.mapper;

import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;

import com.learn.cloud.entity.User;

//@Mapper或者@MapperScan将接口扫描装配到容器中
@Mapper
public interface UserMapperTest01 {

	public User getUserById(Long id);
	
	@Insert("insert into user_info(id, username, password,openid,role) values(#{id}, #{username}, #{password}, #{openid}, #{role});")
	public void insertUser(User user);
}

package com.learn.cloud.test01.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.learn.cloud.entity.User;
import com.learn.cloud.test01.mapper.UserMapperTest01;

@Service
public class UserServiceTest01 {
	
	  @Autowired
	  private UserMapperTest01 userMapperTest01;
	  
	  public User getUserById(Long id) {
		    User user = this.userMapperTest01.getUserById(id);
		    return user;
	  }
	  
	  @Transactional
	  public void insertUser(User user) {
		  userMapperTest01.insertUser(user);
		    @SuppressWarnings("unused")
			int i = 1 / 0;
	  }

}

package com.learn.cloud.test02.mapper;

import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;

import com.learn.cloud.entity.User;

//@Mapper或者@MapperScan将接口扫描装配到容器中
@Mapper
public interface UserMapperTest02 {

	public User getUserById(Long id);
	
	@Insert("insert into user_info(id, username, password,openid,role) values(#{id}, #{username}, #{password}, #{openid}, #{role});")
	public void insertUser(User user);
}

package com.learn.cloud.test02.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.learn.cloud.entity.User;
import com.learn.cloud.test01.mapper.UserMapperTest01;
import com.learn.cloud.test02.mapper.UserMapperTest02;

@Service
public class UserServiceTest02 {
	
	  @Autowired
	  private UserMapperTest02 userMapperTest02;
	  
	  @Autowired
	  private UserMapperTest01 userMapperTest01;
	  
	  public User getUserById(Long id) {
		    User user = this.userMapperTest02.getUserById(id);
		    return user;
	  }
	  
	  @Transactional
	  public void insertUser(User user) {
		  userMapperTest02.insertUser(user);
		    @SuppressWarnings("unused")
			int i = 1 / 0;
	  }
	  
	  @Transactional
	  public void insertUserTest1UserTest2(User user) {
		  userMapperTest01.insertUser(user);
		  userMapperTest02.insertUser(user);
		    @SuppressWarnings("unused")
			int i = 1 / 0;
	  }

}

package com.learn.cloud.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.learn.cloud.entity.User;
import com.learn.cloud.test01.service.UserServiceTest01;
import com.learn.cloud.test02.service.UserServiceTest02;

@RestController
public class MybatisMultiDataSourceController {
	@Autowired
	private UserServiceTest01 userServiceTest01;
	@Autowired
	private UserServiceTest02 userServiceTest02;
	@RequestMapping("/insertUserTest01")
	public Map<String,Object> insertUserTest1(@RequestBody User user) {
		Map<String,Object> map = new HashMap<String,Object>();
		  try {
			  userServiceTest01.insertUser(user);
			map.put("msg", "success");
		  } catch (Exception e) {
				e.printStackTrace();
				map.put("msg", "fail");
		  }
		  return map;
	}
	@RequestMapping("/insertUserTest02")
	public Map<String,Object> insertUserTest2(@RequestBody User user) {
		Map<String,Object> map = new HashMap<String,Object>();
		  try {
			  userServiceTest02.insertUser(user);
			map.put("msg", "success");
		  } catch (Exception e) {
				e.printStackTrace();
				map.put("msg", "fail");
		  }
		  return map;
	}
	
	@RequestMapping("/insertUserTest1UserTest2")
	public Map<String,Object> insertUserTest1UserTest2(@RequestBody User user) {
		Map<String,Object> map = new HashMap<String,Object>();
		  try {
			  userServiceTest02.insertUserTest1UserTest2(user);
			map.put("msg", "success");
		  } catch (Exception e) {
				e.printStackTrace();
				map.put("msg", "fail");
		  }
		  return map;
	}
}

package com.learn.cloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.properties.EnableConfigurationProperties;

import com.learn.cloud.datasource.DBConfig1;
import com.learn.cloud.datasource.DBConfig2;

//@MapperScan(value="com.learn.cloud.mapper")
@EnableConfigurationProperties(value = { DBConfig1.class, DBConfig2.class })
@SpringBootApplication
public class MyBatisApp02 {

	public static void main(String[] args) {
		SpringApplication.run(MyBatisApp02.class, args);
	}
}

 

Leon_Jinhai_Sun
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring Boot + JdbcTemplate + jta-atomikos 解决分布式事务
北辰
10-29 827
JTA全称“Java Transaction API”，JTA事务比JDBC事务更强大。一个JTA事务可以有多个参与者，而一个JDBC事务则被限定在一个单一的数据库连接。所以，当我们在同时操作多个数据库的时候，使用JTA事务就可以弥补JDBC事务的不足。
SpringBoot整合多数据源，atomikos 解决分布式事务报错
AOP_LIU的博客
08-16 3977
背景：SpringBoot整合多数据源及分布式事物管理 1. SpringBoot分布式事物管理：使用springboot+jta+atomikos分布式事物管理 SpringBoot 父类版本为2.1.2 <!-- Maven中的parent 目的: 聚合工程、继承关系(jar包) --> <!-- Spring parent 目的: 统一整合第三方框架...
Springboot 整合jta-atomikos实现多数据源及分布式事务管理——SpringBoot学习
写Bug的小白的博客
04-11 2624
一、POM 文件引入 JAR   在 pom.xml 中引入 jta-atomikos 以及测试包 <!-- mybatis 依赖 --> <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter&lt...
【SpringBoot框架篇】4.集成jta-atomikos实现分布式事务
皓亮君的博客
04-25 4501
springboot集成jta-atomikos实现分布式事务简介引入依赖修改配置文件添加配置读取类创建多数据源,管理事务数据持久化数据库DLL文件模拟事务回滚 简介 1.分布式事务 说到分布式事务，可以理解为，由于分布式而引起的事务不一致的问题。随着项目做大，模块拆分，数据库拆分。一次包含增删改操作数据库涉及到了更新两个不同物理节点的数据库，这样的数据库事务只能保证自己处理的部分的事务，但是整个...
Springboot 整合druid+mybatis+jta分布式事务+多数据源aop注解动态切换 （一篇到位）
热门推荐
默默不代表沉默
12-11 1万+
前言： springboot整合多数据源，大家肯定不陌生，方式不一，但是相信大家整合多数据源，如果涉及到事务，都会非常烦恼，多数据源的事务不是冲突就是失效，而如今网上千篇一律的老年博客，想找到真正解决问题的，非常少。所以我决定出来分享下可用的整合方案，而且是从头到尾的那种。 这一篇我选择的是以AOP注解的方式去进行数据源的动态切换，顺带整合jta-atomikos把烦人的事务问题解决调，持久层...
第十课 SpringBoot 多数据源解决分布式事务（jta + atomikos）
gonghua0502的专栏
06-24 600
SpringBoot 多数据源解决分布式事务主要通过jta + atomikos来生成全局事物管理器，来管理每一个datasource的数据源。 话不多说，直接看操作： （1）引入jta +atomikos相关依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-...
分布式事务JTA/XA atomikos -- 基于springboot的Dubbo + 动态数据源 + mybatis-plus
wdquan19851029的专栏
01-05 2181
本文code地址：https://github.com/wdquan1985/dubbo-dynamicDatasource-jtaAtomikos
springBoot入门总结（八）使用 jta+atomikos 整合springBoot分布式事务
weixin_41557632的博客
02-01 2233
一、JTA：Java Transaction Manager 事务是计算机应用中不可或缺的组件模型，它保证了用户操作的原子性 ( Atomicity )、一致性 ( Consistency )、隔离性 ( Isolation ) 和持久性 ( Durabilily )。 JTA：(Java Transaction Manager)是Java 中对事务进行管理的接口，在Java应用中，调用者实际...
SpringBoot 整合jta+atomikos 解决分布式事务
Eddie'Blog
02-06 214
文章目录目录整合步骤一、准备工作二、新增依赖三、编写YAML样式的配置四、编写实体类读取配置五、编写多数据源与管理事务配置类六、测试效果 目录 整合步骤 准备工作 新增依赖 编写YAML样式的配置 编写实体类读取配置 编写多数据源与管理事务配置类 测试效果 官网地址： https://docs.spring.io/spring-boot/docs/current/reference/html/spring-boot-features.html#boot-features-jta 一、准备工作 1.1
SpringBoot+Atomikos分布式事务及多数据源动态切换，两种demo
08-29
最后，压缩包中的"SpringBoot+Atomikos分布式事务及动态数据源"文件可能包含了具体的代码示例和配置文件，这些资源可以帮助开发者更好地理解和实践上述概念。通过分析和学习这些示例，可以快速上手Spring Boot与...
springboot整合jta实现多数据源事务管理
12-10
在Spring Boot应用中，整合JTA（Java Transaction API）实现多数据源事务管理是一个常见的需求，特别是在分布式系统中，为了确保数据的一致性和完整性。本文将深入探讨如何配置和使用Spring Boot与JTA来管理多个...
SpringBoot整合多数据源，并实现本地分布式事务
03-20
总结，Spring Boot整合多数据源并实现本地分布式事务，需要理解数据源的配置、事务管理、读写分离策略以及分布式事务的协调机制。在实际项目中，结合Atomikos这样的工具，可以有效地处理复杂的事务场景，提高系统的...
Spring boot+Atomikos+JTA+Hibernate+mybatis+MySQL实现分布式事务+多数据源
10-08
本案例主要探讨如何利用Spring Boot、Atomikos、JTA（Java Transaction API）、Hibernate以及MyBatis，结合MySQL数据库，实现一个跨数据源的分布式事务解决方案。 首先，Spring Boot是一个基于Spring框架的快速开发...
springboot-jpa atomikos 分布式事务管理
10-08
总的来说，"springboot-jpa atomikos 分布式事务管理"是解决在SpringBoot项目中，特别是在涉及多个数据库的情况下，如何有效且一致地处理事务的关键技术。通过整合JPA、Hibernate、MyBatis和Atomikos，开发者可以...
方案-基于云架构的校园信息化建设方案.pdf
最新发布
07-29
方案-基于云架构的校园信息化建设方案.pdf
【创新未发表】Matlab实现蛇群优化算法SO-Kmean-Transformer-LSTM负荷预测算法研究.rar
07-29
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
【创新未发表】Matlab实现北方苍鹰优化算法NGO-Kmean-Transformer-LSTM组合状态识别算法研究.rar
07-29
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
【创新未发表】Matlab实现蝗虫优化算法GOA-Kmean-Transformer-BiLSTM组合状态识别算法研究.rar
07-29
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
springboot 整合druid+mybatis+jta分布式事务+多数据源aop注解动态切换
08-30
Spring Boot 是一个用于快速构建 Java 应用程序的框架。它可以与多种其他框架和组件进行整合，以实现更丰富的功能。在这里，我们将讨论如何使用 Spring Boot 整合 Druid、MyBatis、JTA 分布式事务以及多数据源，同时使用 AOP 注解实现动态切换。 首先，我们可以在 Spring Boot 中集成 Druid 数据源。Druid 是一个高性能的 JDBC 连接池，可以提供监控和统计功能。我们可以通过在 pom.xml 文件中添加相关的依赖，并在 application.properties 文件中配置数据源信息，来实现 Druid 的集成。 接下来，我们可以整合 MyBatis 框架，它是一种优秀的持久化解决方案。我们可以使用 MyBatis 来操作数据库，并将其与 Druid 数据源进行整合。为此，我们需要在 pom.xml 文件中添加 MyBatis 和 MyBatis-Spring 的依赖，并配置 MyBatis 的相关配置文件。 此外，我们还可以使用 JTA（Java Transaction API）实现分布式事务。JTA 可以在分布式环境中协调多个参与者的事务操作。我们可以在 pom.xml 文件中添加 JTA 的依赖，并在 Spring Boot 的配置文件中配置 JTA 的相关属性，以实现分布式事务的支持。 在实现多数据源时，我们可以使用 Spring Boot 的 AbstractRoutingDataSource 来实现动态切换数据源。这个类可以根据当前线程或其他条件选择不同的数据源来进行数据操作。我们可以通过继承 AbstractRoutingDataSource 并实现 determineCurrentLookupKey() 方法来指定当前数据源的 key。然后，在配置文件中配置多个数据源，并将数据源注入到 AbstractRoutingDataSource 中，从而实现动态切换。 最后，我们可以使用 AOP（Aspect Oriented Programming）注解来实现动态切换。AOP 是一种编程范式，可以通过在代码中插入特定的切面（Aspect）来实现横切关注点的处理。我们可以在代码中使用注解来标记需要切换数据源的方法，然后使用 AOP 技术来拦截这些方法，并根据注解中指定的数据源信息来进行数据源的切换。 综上所述，通过整合 Druid、MyBatis、JTA 分布式事务以及多数据源，并使用 AOP 注解实现动态切换，我们可以在 Spring Boot 中实现强大而灵活的应用程序。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值