Spring 多数据库事务的一致性（JTA 和 非JTA）

最新推荐文章于 2023-03-04 11:35:16 发布
原创 最新推荐文章于 2023-03-04 11:35:16 发布 · 1.2k 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#JTA #jotm #分布式事务 #多库事务 #夸库事务

本文介绍了一种使用JOTM和xapool实现的Spring4.X+hibernate4.X架构下的跨库事务配置方法，同时提供了另一种不依赖JTA的跨库事务配置方案。
  1. 这里的项目是基于 Spring4.X + hibernate4.X架构的。最近的一个项目需要两个数据库，一个Oracle，一个是Sqlserver。业务中有一些需求需要跨库事务的一致，举个例子：合同签订保存到基于Oracle的ERP数据库，紧接着下发到Sqlserver的WMS数据库。
  2. 以前听说过JTA分布式事务，google到两种分布式框架：JOTM，atomikos。貌似JOTM简便点，就它了。
  3. 这种方式需要的jar包，首先在JOTM官网下面所有的jar包文件（文末提供下载），下图中选中的jar文件都是需要导入的

     

    首先配置DataSource和SessionFactory

 

<!-- 数据库连接池 -->
	<bean id="dataSource1" class="org.enhydra.jdbc.pool.StandardXAPoolDataSource">
		 <property name="dataSource">  
	        <bean class="org.enhydra.jdbc.standard.StandardXADataSource" destroy-method="shutdown">  
	            <property name="transactionManager" ref="jotm" />  
	            <property name="driverName" value="oracle.jdbc.driver.OracleDriver" />  
	            <property name="url" value="jdbc:oracle:thin:@192.168.1.200:1521:orcl" />  
	        </bean>  
	    </property>     
	    <property name="user" value="${jdbc.username}" />  
	    <property name="password" value="${jdbc.password}" /> 
	</bean>
	<bean id="dataSource2" class="org.enhydra.jdbc.pool.StandardXAPoolDataSource"
		>
		 <property name="dataSource">  
	        <bean class="org.enhydra.jdbc.standard.StandardXADataSource" destroy-method="shutdown">  
	            <property name="transactionManager" ref="jotm" />  
	            <property name="driverName" value="com.microsoft.sqlserver.jdbc.SQLServerDriver" />  
	            <property name="url" value="jdbc:sqlserver://192.168.1.200:1433;DatabaseName=middle_db" />  
	        </bean>  
	    </property>     
	    <property name="user" value="${jdbc2.username}" />  
	    <property name="password" value="${jdbc2.password}" />  
	</bean>
	<bean id="sessionFactory1"
		class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
		<property name="dataSource" ref="dataSource1" />
		<property name="packagesToScan">
			<list>
				<value>com.sy.domain</value>
			</list>
		</property>
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">
					org.hibernate.dialect.OracleDialect
				</prop>
				<prop key="hibernate.show_sql">true</prop>
				<prop key="hibernate.autoReconnect">true</prop>
				<!-- <prop key="hibernate.hbm2ddl.auto">update</prop> -->
			</props>
		</property>
	</bean>
	
	<bean id="sessionFactory2"
		class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
		<property name="dataSource" ref="dataSource2" />
		<property name="packagesToScan">
			<list>
				<value>com.sy.domain</value>
			</list>
		</property>
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">
					org.hibernate.dialect.SQLServerDialect
				</prop>
				<prop key="hibernate.show_sql">true</prop>
				<prop key="hibernate.autoReconnect">true</prop>
				<!-- <prop key="hibernate.hbm2ddl.auto">update</prop> -->
			</props>
		</property>
	</bean>
	<!-- erp.dao -->
	<bean id="commonDao" class="com.sy.dao.impl.CommonDaoImpl" >
		<property name="sessionFactory" ref="sessionFactory1"/>
	</bean>
	<!-- wms.dao -->
	<bean id="commonDao2" class="com.sy.dao.impl.CommonDaoImpl" >
		<property name="sessionFactory" ref="sessionFactory2"/>
	</bean>

  因为我们要操作两个数据库，所以配置两个datasource，两个sessionfactory。需要注意的是我们这里是JOTM和xapool实现的分布式事务。JOTM实现了TransactionManager的功能，xapool通过使用非XA数据库驱动实现了XA数据库驱动的效果，具体这个以后再写文章。这里连接池的配置按照上面的文档配置即可。

 

这里DAO层因为两个数据库所以配置了两个。在Service层可以选择一起注入或者单个注入。

 

下面配置事务

<bean id="jotm" class="com.sy.utils.JotmFactoryBean"/>  
  <bean id="jtaTransactionManager"  class="org.springframework.transaction.jta.JtaTransactionManager">   
     <property name="userTransaction" ref="jotm" />  
	</bean> 
	<tx:advice id="txAdvice" transaction-manager="jtaTransactionManager">
		<tx:attributes>
			<!-- 传播行为 -->
			<tx:method name="save*" propagation="REQUIRED"  rollback-for="com.sy.exceptions.MyException"/>
			<tx:method name="insert*" propagation="REQUIRED" rollback-for="com.sy.exceptions.MyException"/>
			<tx:method name="add*" propagation="REQUIRED" rollback-for="com.sy.exceptions.MyException"/>
			<tx:method name="create*" propagation="REQUIRED" rollback-for="com.sy.exceptions.MyException"/>
			<tx:method name="delete*" propagation="REQUIRED" rollback-for="com.sy.exceptions.MyException"/>
			<tx:method name="update*" propagation="REQUIRED" rollback-for="com.sy.exceptions.MyException"/>
			<tx:method name="find*" propagation="SUPPORTS" read-only="true" />
			<tx:method name="select*" propagation="SUPPORTS" read-only="true" />
			<tx:method name="get*" propagation="SUPPORTS" read-only="true" />
		</tx:attributes>
	</tx:advice>
	<!-- 切面 -->
	<aop:config expose-proxy="true">
        <aop:pointcut id="bussinessService" expression="execution(* com.sy.service.*.*(..))" />
        <aop:advisor pointcut-ref="bussinessService" advice-ref="txAdvice"/>
    </aop:config>
     <tx:annotation-driven transaction-manager="jtaTransactionManager"/>

  com.sy.utils.JotmFactoryBean需要手动实现，因为spring4.x不在提供JtaTransactionManager 的默认实现。

 

 

到这里JTA分布式事务的配置已经完成，下面我们看看Service层，和junit测试

@Service
public class CommonServiceImpl implements CommonService{
	
	/** serialVersionUID*/
	private static final long serialVersionUID = -5991777455696969065L;
	@Resource
	private CommonDao commonDao;
	@Resource
	private CommonDao commonDao2;
        //测试两个数据库的事务
	@Override
	public void saveTest() throws MyException {
		commonDao.update("update Dictionary set name=? where id=? ", new Value().add("货主类型").add(1l).getParams());
		commonDao2.update("delete Member where id>25");
                int i = 1/0; //这里异常，前面配置正确的话事务会回滚
	}

}

 

   因为这是一个公共的Service层，需要操作两个数据库，所以两个DAO一起注入。下面是Junit测试代码

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:spring/applicationContext-*.xml"})
public class TestSupport extends AbstractJUnit4SpringContextTests {

        @Autowired
	private CommonService commonService;
	@Test
	public void save() throws MyException{
		commonService.saveTest();
	}
	public CommonService getCommonService() {
		return commonService;
	}
	public void setCommonService(CommonService commonService) {
		this.commonService = commonService;
	}


}

  运行结果如我们所料，事务回滚，OK！

 

下面是直接配置的方式，这种方式是一个老同事那边看到的。当时惊呼不用jta也能实现跨库事务啊。跟普通的单数据库项目配置一样，只是DataSource，SessionFactory，transactionmanager等都是两个。下面是配置

<!-- 数据库连接池 -->
	<bean id="dataSource1" class="com.alibaba.druid.pool.DruidDataSource"
		destroy-method="close">
		<property name="url" value="${jdbc.url}" />
		<property name="username" value="${jdbc.username}" />
		<property name="password" value="${jdbc.password}" />
		<property name="driverClassName" value="${jdbc.driver}" />
		<property name="maxActive" value="${jdbc.maxActive}" />
		<property name="minIdle" value="${jdbc.minIdle}" />
	</bean>
	<bean id="dataSource2" class="com.alibaba.druid.pool.DruidDataSource"
		destroy-method="close">
		<property name="url" value="${jdbc2.url}" />
		<property name="username" value="${jdbc2.username}" />
		<property name="password" value="${jdbc2.password}" />
		<property name="driverClassName" value="${jdbc2.driver}" />
		<property name="maxActive" value="${jdbc2.maxActive}" />
		<property name="minIdle" value="${jdbc2.minIdle}" />
	</bean>
	<bean id="sessionFactory1"
		class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
		<property name="dataSource" ref="dataSource1" />
		<property name="packagesToScan">
			<list>
				<value>com.sy.domain</value>
			</list>
		</property>
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">
					org.hibernate.dialect.OracleDialect
				</prop>
				<prop key="hibernate.show_sql">true</prop>
				<prop key="hibernate.autoReconnect">true</prop>
				<!-- <prop key="hibernate.hbm2ddl.auto">update</prop> -->
			</props>
		</property>
	</bean>
	
	<bean id="sessionFactory2"
		class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
		<property name="dataSource" ref="dataSource2" />
		<property name="packagesToScan">
			<list>
				<value>com.sy.domain</value>
			</list>
		</property>
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">
					org.hibernate.dialect.SQLServerDialect
				</prop>
				<prop key="hibernate.show_sql">true</prop>
				<prop key="hibernate.autoReconnect">true</prop>
				<!-- <prop key="hibernate.hbm2ddl.auto">update</prop> -->
			</props>
		</property>
	</bean>
	
	<bean id="commonDao" class="com.sy.dao.impl.CommonDaoImpl" >
		<property name="sessionFactory" ref="sessionFactory1"/>
	</bean>
	
	<bean id="commonDao2" class="com.sy.dao.impl.CommonDaoImpl" >
		<property name="sessionFactory" ref="sessionFactory2"/>
	</bean>
     <bean id="transactionManager1" class="org.springframework.orm.hibernate4.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory1" />
    </bean>
    
    <bean id="transactionManager2" class="org.springframework.orm.hibernate4.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory2" />
    </bean>
	
	<tx:advice id="txAdvice1" transaction-manager="transactionManager1">
		<tx:attributes>
			<!-- 传播行为 -->
			<tx:method name="save*" propagation="REQUIRED"  rollback-for="com.sy.exceptions.MyException"/>
			<tx:method name="insert*" propagation="REQUIRED" rollback-for="com.sy.exceptions.MyException"/>
			<tx:method name="add*" propagation="REQUIRED" rollback-for="com.sy.exceptions.MyException"/>
			<tx:method name="create*" propagation="REQUIRED" rollback-for="com.sy.exceptions.MyException"/>
			<tx:method name="delete*" propagation="REQUIRED" rollback-for="com.sy.exceptions.MyException"/>
			<tx:method name="update*" propagation="REQUIRED" rollback-for="com.sy.exceptions.MyException"/>
			<tx:method name="find*" propagation="SUPPORTS" read-only="true" />
			<tx:method name="select*" propagation="SUPPORTS" read-only="true" />
			<tx:method name="get*" propagation="SUPPORTS" read-only="true" />
		</tx:attributes>
	</tx:advice>
	
	<tx:advice id="txAdvice2" transaction-manager="transactionManager2">
		<tx:attributes>
			<!-- 传播行为 -->
			<tx:method name="save*" propagation="REQUIRED"  rollback-for="com.sy.exceptions.MyException"/>
			<tx:method name="insert*" propagation="REQUIRED" rollback-for="com.sy.exceptions.MyException"/>
			<tx:method name="add*" propagation="REQUIRED" rollback-for="com.sy.exceptions.MyException"/>
			<tx:method name="create*" propagation="REQUIRED" rollback-for="com.sy.exceptions.MyException"/>
			<tx:method name="delete*" propagation="REQUIRED" rollback-for="com.sy.exceptions.MyException"/>
			<tx:method name="update*" propagation="REQUIRED" rollback-for="com.sy.exceptions.MyException"/>
			<tx:method name="find*" propagation="SUPPORTS" read-only="true" />
			<tx:method name="select*" propagation="SUPPORTS" read-only="true" />
			<tx:method name="get*" propagation="SUPPORTS" read-only="true" />
		</tx:attributes>
	</tx:advice>
	
	<!-- 切面 -->
	<aop:config expose-proxy="true">
        <aop:pointcut id="bussinessService1" expression="execution(* com.sy.service.*.*(..))" />
        <aop:advisor pointcut-ref="bussinessService1" advice-ref="txAdvice1"/>
    </aop:config>
    
    <aop:config expose-proxy="true">
        <aop:pointcut id="bussinessService2" expression="execution(* com.sy.service.*.*(..))" />
        <aop:advisor pointcut-ref="bussinessService2" advice-ref="txAdvice2"/>
    </aop:config>

  这里配置和普通单库配置基本一样，连接池也是自由选择。但是都是两个配置，spring4对多个事务配置也是支持的。测试代码和上面JTA配置的一样，不再给出。

  

 

 

 

详解基于spring多数据源动态调用及其事务处理
08-30
本篇文章主要介绍了基于spring多数据源动态调用及其事务处理 ，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Spring配置JTA事务管理
03-01
本篇文章将深入探讨如何在Spring中配置JTA事务管理，以实现跨数据库和资源的事务一致性。 首先，让我们了解JTA的基本概念。JTA是一个规范，它定义了接口和API，使得应用程序可以控制跨越多个数据存储（如数据库、...
spring 多数据源一致性事务方案
Java_Jsp_Ssh的博客
10-17 711
https://www.cnblogs.com/ityouknow/p/4977136.html spring 多数据源配置 spring 多数据源配置一般有两种方案： 1、在spring项目启动的时候直接配置两个不同的数据源，不同的sessionFactory。在dao 层根据不同业务自行选择使用哪个数据源的session来操作。 2、配置多个不同的数据源，使用一个sessionFact...
Spring+atmikos多数据源事务一致性
qazxsw635241的博客
10-29 425
1、pom.xml <atomikos.version>4.0.2</atomikos.version> <dependency> <groupId>javax.transaction</groupId> <artifactId>jta</artifactId> <version>1.1&l...
将非事务性资源绑定到JTA事务中的几种模式
最佳 Java 编程
05-29 211
我最近发表了一篇有关如何将非事务性资源（如Web服务/微服务）绑定到全局分布式事务中的文章，以便自动处理恢复。 多年来，我经常不得不将“非事务性”系统集成到Java EE应用程序服务器中，而数据一致性通常是讨论的话题，甚至是非功能性需求。 我将“非事务性”用引号引起来，因为通常系统包含确保数据一致性的方法，例如使用调用进行补偿，但是这些系统通常不是您传统上称为事务性的。 当然，无法将Java...
通过日志来看Spring跨库更新操作的事务
weixin_34405354的博客
03-26 243
通过日志来看Spring跨库更新操作的事务 场景介绍： 一个项目俩个数据源，连接俩个不同的库 数据源初始化 @Configuration @MapperScan(basePackages = "com.qing.mapper.payment", sqlSessionTemplateRef = "paymentSqlSessionTe...
spring 结合druid和hibernate使用jta配置分布式事务
10-31
在企业级应用开发中，确保数据的一致性和完整性至关重要，这就需要用到事务管理。Spring框架提供了强大的事务管理功能，而分布式事务则是处理多数据库操作时的关键技术。本篇将详细讲解如何在Spring环境中结合Druid...
Springboot 动态多数据源 jta分布式事务
06-13
在微服务架构中，跨服务的数据一致性是非常重要的，这就需要用到分布式事务。JTA是Java平台中处理分布式事务的标准API，它允许应用程序在一个全局事务中操作多个资源（如数据库、消息队列等）。Spring Boot支持JTA...
springboot整合jta实现多数据源事务管理
12-10
在Spring Boot应用中，整合JTA（Java Transaction API）实现多数据源事务管理是一个常见的需求，特别是在分布式系统中，为了确保数据的一致性和完整性。本文将深入探讨如何配置和使用Spring Boot与JTA来管理多个...
Spring boot+Atomikos+JTA+Hibernate+MySQL实现分布式事务+多数据源（可运行）
09-12
本项目使用Spring Boot、Atomikos、JTA（Java Transaction API）、Hibernate和MySQL来实现分布式事务处理和多数据源管理，以确保在多个数据库操作之间保持事务的ACID特性。 首先，Spring Boot作为微服务开发的主流...
分布式环境下的数据一致性
yinni11的博客
09-28 3526
互联网技术的四大法宝。   淘宝应用场景   需求：1.出账，出款需求，支付宝调用银行接口，进行转账。即自己的系统调第三方系统             2.A系统调用B系统的接口，注意什么事项？ 在A系统多次调用B系统的接口，例如当支付宝发送多次请求的时候，即重新的两次 （请求单号不变），不是单独的两次（）。B方是银行系统，不能要求银行幂等。怎么解决。            3.银行...
java jta mysql_JTA实现跨数据库操作
weixin_39748183的博客
02-16 144
EJB3.0实现跨数据库进行存取环境：MySQL5.1/JBoss5.11.加入跨数据库的数据源，由于JBoss没有提供mysql的配置文件，所以要手工加入：mysql-xa-ds.xml：(注意：不是mysql-ds.xml)MySqlXADS1com.mysql.jdbc.jdbc2.optional.MysqlXADataSourcejdbc:mysql://localhost/ejb?us...
使用JTA实现跨库事务
wang77777的博客
02-28 591
本文是基于atomikos实现的JTA跨库事务 示例中的数据访问层为Hibernate，可替换为喜欢的任意的方式。 具体使用比较简单，只是需要在配置上做一些修改 具体测试源码见附件，其中核心配置如下： [code="XML"] DataSourceA com.mysql.jdbc.jdbc2.optional.Mys...
JTA 跨库事务
bushyou的专栏
03-18 369
前面关于活动系统的数据一致性，是用事务来完成的。 但是现在都是大数据，因此都会存在跨库的事务。所以对这个进行了一些了解，做下整理。   J2EE规范 ØJDBC Ø…… ØJTA ü JTA定义了一种标准API，应用系统由此可以访问各种事务监控。 ØJTS   üCORBA OTS事务监控的基本实现。JTS规定了事务管理器的实现方式。该事务管理器是在高层支持Java Tran...
spring+hibernate+tomcat+JTA跨数据库事务
Roger★L☆M☆J★
10-28 1817
 随着公司网站的发展，网站上的产品越来越多，单个mysql库表太多不好维护,我着手开始分库表，由于服务器是tomcat的本身不支持JTA,我就打算用spring+Jotm的方式来实现跨数据库的事务管理,spring的配置文件如下: datasoruce.xml://jotm事务管理          ///第一个datasource
Spring JDBC - JTA实现分布式事务
qq_36423495的博客
03-04 339
Spring JDBC - JTA实现分布式事务
Spring在多线程环境下如何确保事务一致性
热门推荐
m0_53157173的博客
10-20 1万+
如何实现Spring在多线程环境下的事物一致性呢？还不快学起来！！！
AbstractRoutingDataSource数据源动态切换、跨库事物失效问题解决方案
z69183787的专栏
08-15 2012
系统架构设计、每个企业一个企业库、通过数据源切在平台库、和企业库之间动态切换完成业务操作。1、Spring@Transactional不支持跨数据源事物，Spring 事物控制是基于数据库链接进行的，当数据源切换后，数据库链接切换，事物回滚只能回退，当前持有的链接。 2、Spring开启事物后，会将当前数据库及数据库链接资源进行线程绑定，导致数据源切换失效（数据源切换执行后，并未获取到新的数据库链接）。基于InheritableThreadLocal + aop 针对添加了跨库事务注解的方法进行拦截、线程标
Spring多数据源事务管理实践与JTA案例解析
测试用例通常包含对多个数据源的操作，以确保事务的原子性和一致性。 在实现Spring多数据源事务管理的JTA例子中，一个常见的配置文件示例可能包括： - Spring XML配置文件，声明了两个数据源和一个JTA事务管理器：...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值