Spring实现分布式事务JTA(使用atomiko实现)

最新推荐文章于 2021-11-22 14:55:17 发布
最新推荐文章于 2021-11-22 14:55:17 发布
阅读量175 收藏 1
点赞数
分类专栏： 项目相关

分布式事务是指事务的参与者、支持事务的服务器、资源管理器以及事务管理器分别位于分布系统的不同节点之上，在两个或多个网络计算机资源上访问并且更新数据，将两个或多个网络计算机的数据进行的多次操作作为一个整体进行处理。如不同银行账户之间的转账。

       对于在项目中接触到JTA，大部分的原因是因为在项目中需要操作多个数据库，同时，可以保证操作的原子性，保证对多个数据库的操作一致性。 

      1、项目结构图：


2、pom.xml

[html]  view plain  copy
  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  2.   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
  3.   <modelVersion>4.0.0</modelVersion>  
  4.   <groupId>org.nercita.ltxx</groupId>  
  5.   <artifactId>jtaTest</artifactId>  
  6.   <version>0.0.1-SNAPSHOT</version>  
  7.   <packaging>jar</packaging>  
  8.   
  9.   <name>jtaTest</name>  
  10.   <url>http://maven.apache.org</url>  
  11.   
  12.   <properties>  
  13.     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
  14.     <spring.version>4.1.6.RELEASE</spring.version>  
  15.   </properties>  
  16.   
  17.     <dependencies>    
  18.         <dependency>  
  19.             <groupId>junit</groupId>  
  20.             <artifactId>junit</artifactId>  
  21.             <version>4.12</version>  
  22.             <scope>test</scope>  
  23.         </dependency>  
  24.                          
  25.         <dependency>  
  26.             <groupId>org.springframework</groupId>  
  27.             <artifactId>spring-test</artifactId>  
  28.             <version>${spring.version}</version>  
  29.             <scope>provided</scope>  
  30.         </dependency>  
  31.   
  32.         <!-- 数据库驱动-mysql -->  
  33.         <dependency>  
  34.               <groupId>mysql</groupId>  
  35.               <artifactId>mysql-connector-java</artifactId>  
  36.               <version>5.1.26</version>  
  37.         </dependency>  
  38.           
  39.         <!-- 数据库驱动-oracle -->  
  40.         <dependency>           
  41.               <groupId>com.oracle</groupId>  
  42.               <artifactId>ojdbc6</artifactId>  
  43.               <version>12.1.0.1</version>  
  44.         </dependency>         
  45.         <dependency>  
  46.             <groupId>com.atomikos</groupId>  
  47.             <artifactId>transactions-jdbc</artifactId>  
  48.             <version>3.9.3</version>  
  49.         </dependency>     
  50.         <dependency>  
  51.             <groupId>javax.transaction</groupId>  
  52.             <artifactId>jta</artifactId>  
  53.             <version>1.1</version>  
  54.         </dependency>     
  55.   
  56.         <!-- javaee-api包含了JavaEE规范中的api,如servlet-api,persistence-api, transaction-api等 -->  
  57.         <dependency>  
  58.             <groupId>javax</groupId>  
  59.             <artifactId>javaee-api</artifactId>  
  60.             <version>7.0</version>  
  61.         </dependency>         
  62.         <dependency>  
  63.             <groupId>org.springframework</groupId>  
  64.             <artifactId>spring-context</artifactId>  
  65.             <version>${spring.version}</version>  
  66.         </dependency>         
  67.         <dependency>  
  68.             <groupId>org.springframework</groupId>  
  69.             <artifactId>spring-jdbc</artifactId>  
  70.             <version>${spring.version}</version>  
  71.         </dependency>  
  72.           
  73.         <dependency>  
  74.             <groupId>org.springframework</groupId>  
  75.             <artifactId>spring-aspects</artifactId>  
  76.             <version>${spring.version}</version>  
  77.         </dependency>  
  78.           
  79.           
  80.         <!-- aspectj weaver.jar 这是SpringAOP所要用到的依赖包 -->  
  81.         <dependency>  
  82.             <groupId>org.aspectj</groupId>  
  83.             <artifactId>aspectjweaver</artifactId>  
  84.             <version>1.8.2</version>  
  85.         </dependency>  
  86.         <dependency>  
  87.             <groupId>org.aspectj</groupId>  
  88.             <artifactId>aspectjrt</artifactId>  
  89.             <version>1.8.2</version>  
  90.         </dependency>   
  91.   
  92.   
  93.     </dependencies>  
  94.   
  95. </project>  


2、applicationContext.xml

[html]  view plain  copy
  1. <?xml version="1.0" encoding="UTF-8" standalone="no"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:aop="http://www.springframework.org/schema/aop"   
  4.     xmlns:context="http://www.springframework.org/schema/context"  
  5.     xmlns:jee="http://www.springframework.org/schema/jee"   
  6.     xmlns:tx="http://www.springframework.org/schema/tx"  
  7.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  8.     xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd     
  9.                         http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd     
  10.                         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd     
  11.                         http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.0.xsd     
  12.                         http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd">  
  13.     <!-- 引入属性文件 -->  
  14.     <context:property-placeholder location="classpath*:/application.properties" />  
  15.       
  16.     <!-- 对于没有被IOC容器管理的对象也可以使用依赖注入 -->  
  17.     <context:spring-configured />   
  18.   
  19.     <!-- 注解bean及依赖注入 -->  
  20.     <context:component-scan base-package="org.nercita.ltxx.jtatest" />  
  21.       
  22.       
  23.     <!-- mysql数据源1 -->  
  24.     <bean id="masterDataSource" class="com.atomikos.jdbc.AtomikosDataSourceBean"  
  25.         init-method="init" destroy-method="close">  
  26.         <description>master xa datasource</description>  
  27.         <property name="uniqueResourceName">  
  28.             <value>masterDataSource</value>  
  29.         </property>  
  30.         <property name="xaDataSourceClassName" value="com.mysql.jdbc.jdbc2.optional.MysqlXADataSource" />  
  31.         <property name="xaProperties">  
  32.             <props>  
  33.                 <prop key="user">root</prop>  
  34.                 <prop key="password">0729</prop>  
  35.                 <prop key="URL">jdbc:mysql://127.0.0.1:3306/master</prop>  
  36.             </props>  
  37.         </property>       
  38.         <property name="poolSize" value="10"/>   
  39.     </bean>  
  40.   
  41.     <!-- mysql数据源1 -->  
  42.     <bean id="slaveDataSource" class="com.atomikos.jdbc.AtomikosDataSourceBean"  
  43.         init-method="init" destroy-method="close">  
  44.         <description>slave xa datasource</description>  
  45.         <property name="uniqueResourceName">  
  46.             <value>slaveDataSource</value>  
  47.         </property>  
  48.         <property name="xaDataSourceClassName" value="com.mysql.jdbc.jdbc2.optional.MysqlXADataSource" />  
  49.         <property name="xaProperties">  
  50.             <props>  
  51.                 <prop key="user">root</prop>  
  52.                 <prop key="password">0729</prop>  
  53.                 <prop key="URL">jdbc:mysql://127.0.0.1:3306/slave</prop>  
  54.             </props>  
  55.         </property>       
  56.         <property name="poolSize" value="10"/>  
  57.     </bean>  
  58.   
  59.     <!-- atomikos事务管理器 -->  
  60.     <bean id="atomikosTransactionManager" class="com.atomikos.icatch.jta.UserTransactionManager"  
  61.         init-method="init" destroy-method="close">  
  62.         <description>UserTransactionManager</description>  
  63.         <property name="forceShutdown">  
  64.             <value>true</value>  
  65.         </property>  
  66.     </bean>  
  67.     <!-- atomikos用户事务实现 -->  
  68.     <bean id="atomikosUserTransaction" class="com.atomikos.icatch.jta.UserTransactionImp">  
  69.         <property name="transactionTimeout" value="300" />  
  70.     </bean>  
  71.   
  72.     <!-- spring 事务管理器 -->  
  73.     <bean id="springTransactionManager" class="org.springframework.transaction.jta.JtaTransactionManager">  
  74.         <!--注入 atomikos事务管理器 -->  
  75.         <property name="transactionManager">  
  76.             <ref bean="atomikosTransactionManager" />  
  77.         </property>  
  78.         <!--注入 atomikos用户事务实现 -->  
  79.         <property name="userTransaction">  
  80.             <ref bean="atomikosUserTransaction" />  
  81.         </property>  
  82.     </bean>  
  83.   
  84.     <!-- spring事务模板 -->  
  85.     <bean id="transactionTemplate"  class="org.springframework.transaction.support.TransactionTemplate">  
  86.         <property name="transactionManager">  
  87.             <ref bean="springTransactionManager" />  
  88.         </property>  
  89.     </bean>    
  90.   
  91.     <!--jdbc模板  -->  
  92.     <bean id="masterJdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">  
  93.         <constructor-arg>  
  94.             <ref bean="masterDataSource" />  
  95.         </constructor-arg>  
  96.     </bean>  
  97.   
  98.     <!--jdbc模板  -->  
  99.     <bean id="slaveJdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">  
  100.         <constructor-arg>  
  101.             <ref bean="slaveDataSource" />  
  102.         </constructor-arg>  
  103.     </bean>  
  104.    
  105.      <!-- 开启Spring注解式事务 -->   
  106.     <tx:annotation-driven transaction-manager="springTransactionManager"/>    
  107.   
  108.   
  109. </beans>  


ps：数据库和表需自行创建

 

3、java类

dao：

[html]  view plain  copy
  1. package org.nercita.ltxx.jtatest.dao;  
  2.   
  3. import javax.annotation.Resource;  
  4.   
  5. import org.springframework.jdbc.core.JdbcTemplate;  
  6. import org.springframework.stereotype.Repository;  
  7.   
  8. @Repository  
  9. public class JtaTestMasterDao{  
  10.   
  11.     @Resource(name="masterJdbcTemplate")  
  12.     JdbcTemplate masterJdbcTemplate;  
  13.   
  14.     public String master() {  
  15.         masterJdbcTemplate.execute("update teacher set name='master' where id=1");  
  16.         return "success";  
  17.     }  
  18.   
  19.     public void update() {  
  20.         masterJdbcTemplate.execute("update teacher set name='8' where id=1");  
  21.         System.out.println("update");  
  22.         masterJdbcTemplate.execute("fff teacher set name=''6' where id=1");  
  23.     }  
  24.   
  25. }  


 

[html]  view plain  copy
  1. package org.nercita.ltxx.jtatest.dao;  
  2.   
  3.   
  4. import javax.annotation.Resource;  
  5.   
  6. import org.springframework.jdbc.core.JdbcTemplate;  
  7. import org.springframework.stereotype.Repository;  
  8.   
  9. @Repository  
  10. public class JtaTestSlaveDao{  
  11.   
  12.     @Resource(name="slaveJdbcTemplate")  
  13.     JdbcTemplate slaveJdbcTemplate;  
  14.      
  15.       
  16.     public String slave() {  
  17.         slaveJdbcTemplate.execute("update student set name='slave' where id=1");              
  18.         return "success";  
  19.     }     
  20.   
  21. }  


service：

[html]  view plain  copy
  1. package org.nercita.ltxx.jtatest.service;  
  2.   
  3. import javax.annotation.Resource;  
  4. import javax.transaction.SystemException;  
  5. import javax.transaction.UserTransaction;  
  6.   
  7. import org.nercita.ltxx.jtatest.dao.JtaTestMasterDao;  
  8. import org.nercita.ltxx.jtatest.dao.JtaTestSlaveDao;  
  9. import org.springframework.beans.factory.annotation.Autowired;  
  10. import org.springframework.stereotype.Service;  
  11. import org.springframework.transaction.TransactionStatus;  
  12. import org.springframework.transaction.annotation.Transactional;  
  13. import org.springframework.transaction.jta.JtaTransactionManager;  
  14. import org.springframework.transaction.support.TransactionCallback;  
  15. import org.springframework.transaction.support.TransactionCallbackWithoutResult;  
  16. import org.springframework.transaction.support.TransactionTemplate;  
  17.   
  18.   
  19. @Service  
  20. public class JtaTestService{  
  21.     @Resource(name = "springTransactionManager")  
  22.     private JtaTransactionManager txManager;  
  23.     @Autowired  
  24.     private JtaTestMasterDao jtaTestMasterDao;  
  25.     @Autowired  
  26.     private JtaTestSlaveDao jtaTestSlaveDao;    
  27.   
  28.     @Resource(name = "transactionTemplate")  
  29.     private TransactionTemplate transactionTemplate;    
  30.      
  31.     //编程式  
  32.     public String test() {  
  33.          UserTransaction userTx = txManager.getUserTransaction();   
  34.          try {                 
  35.              userTx.begin();       
  36.              jtaTestMasterDao.master();   
  37.              jtaTestSlaveDao.slave();      
  38.              int a=1/0;  
  39.              System.out.println(a);  
  40.              userTx.commit();  
  41.          } catch (Exception e) {  
  42.              System.out.println("捕获到异常，进行回滚" + e.getMessage());  
  43.              e.printStackTrace();  
  44.              try {  
  45.                  userTx.rollback();  
  46.              } catch (IllegalStateException e1) {  
  47.                 System.out.println("IllegalStateException:" + e1.getMessage());  
  48.              } catch (SecurityException e1) {  
  49.                  System.out.println("SecurityException:" + e1.getMessage());  
  50.              } catch (SystemException e1) {  
  51.                  System.out.println("SystemException:" + e1.getMessage());  
  52.              }                
  53.          }  
  54.         return null;  
  55.     }  
  56.       
  57.       
  58.     //声明式  
  59.     @Transactional  
  60.     public void update(){  
  61.         jtaTestMasterDao.master();   
  62.         int a=1/0;  
  63.         System.out.println(a);  
  64.         jtaTestSlaveDao.slave();     
  65.   
  66.     }  
  67.       
  68.       
  69.     //事务模板方式  
  70.     public void test3() {    
  71.   
  72.             transactionTemplate.execute(new TransactionCallbackWithoutResult(){    
  73.                 @Override    
  74.                 protected void doInTransactionWithoutResult(TransactionStatus status) {    
  75.                     try {    
  76.                         jtaTestMasterDao.master();          
  77.                         jtaTestSlaveDao.slave();     
  78.                         int a=1/0;  
  79.                         System.out.println(a);  
  80.                     } catch (Exception ex) {    
  81.                         // 通过调用 TransactionStatus 对象的 setRollbackOnly() 方法来回滚事务。    
  82.                         status.setRollbackOnly();    
  83.                         ex.printStackTrace();    
  84.                     }    
  85.                 }    
  86.             });           
  87.   
  88.   
  89.                /*   
  90.                 //有返回值的回调  
  91.                  Object obj=transactionTemplate.execute(new TransactionCallback(){  
  92.                     @Override  
  93.                     public Object doInTransaction(TransactionStatus status) {  
  94.   
  95.                         return 1;  
  96.                     }    
  97.                 });    
  98.                 */  
  99.         }    
  100.   
  101.   
  102. }  

controller(本文直接使用controller进行测试)

[html]  view plain  copy
  1. package org.nercita.ltxx.jtatest.web;  
  2.   
  3. import org.junit.Test;  
  4. import org.junit.runner.RunWith;  
  5. import org.nercita.ltxx.jtatest.service.JtaTestService;  
  6. import org.springframework.beans.factory.annotation.Autowired;  
  7. import org.springframework.stereotype.Controller;  
  8. import org.springframework.test.context.ContextConfiguration;  
  9. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;  
  10.   
  11.   
  12. @RunWith(SpringJUnit4ClassRunner.class)  
  13. @ContextConfiguration(locations = "classpath:applicationContext.xml")  
  14. @Controller  
  15. public class JtaTestController {     
  16.     @Autowired  
  17.     private JtaTestService jtaTestService;  
  18.     //MySQL的数据库引擎必须是InnoDB，否则无法回滚  
  19.     @Test  
  20.     public void test(){  
  21.         jtaTestService.test();  
  22.     }  
  23.     @Test  
  24.     public void test2(){  
  25.         jtaTestService.update();  
  26.     }  
  27.   
  28.     @Test  
  29.     public void test3(){  
  30.         jtaTestService.test3();  
  31.     }  
  32. }  



4、数据源详细参数配置

[html]  view plain  copy
  1.  <!-- 两个数据源的功用配置，方便下面直接引用 -->  
  2.  <bean id="abstractXADataSource" class="com.atomikos.jdbc.AtomikosDataSourceBean" init-method="init"   
  3.          destroy-method="close" abstract="true">   
  4.     <property name="xaDataSourceClassName" value="com.mysql.jdbc.jdbc2.optional.MysqlXADataSource"/>   
  5.     <property name="poolSize" value="10" />   
  6.     <property name="minPoolSize" value="10"/>   
  7.     <property name="maxPoolSize" value="30"/>   
  8.     <property name="borrowConnectionTimeout" value="60"/>  <!--获取连接失败重新获等待最大时间，在这个时间内如果有可用连接，将返回-->  
  9.     <property name="reapTimeout" value="20"/> <!--最大获取数据时间，如果不设置这个值，Atomikos使用默认的5分钟，那么在处理大批量数据读取的时候，一旦超过5分钟，就会抛出类似 Resultset is close 的错误.-->          
  10.     <property name="maxIdleTime" value="60"/>    <!--最大闲置时间，超过最小连接池连接的连接将将关闭-->  
  11.     <property name="maintenanceInterval" value="60" />  <!--连接回收时间-->      
  12.     <property name="loginTimeout" value="60" />     <!--java数据库连接池，最大可等待获取datasouce的时间-->  
  13.     <property name="logWriter" value="60"/>  
  14.     <property name="testQuery">  
  15.         <value>select 1</value>  
  16.     </property>  
  17.   
  18. </bean>   
  19. <!-- 配置第一个数据源 -->  
  20. <bean id="dataSource" parent="abstractXADataSource">  
  21.      <!-- value只要两个数据源不同就行，随便取名 -->  
  22.     <property name="uniqueResourceName" value="mysql/sitestone" />  
  23.     <property name="xaDataSourceClassName"  
  24.         value="com.mysql.jdbc.jdbc2.optional.MysqlXADataSource" />  
  25.     <property name="xaProperties">  
  26.         <props>  
  27.             <prop key="URL">${jdbc.url}</prop>  
  28.             <prop key="user">${jdbc.username}</prop>  
  29.             <prop key="password">${jdbc.password}</prop>  
  30.         </props>  
  31.     </property>  
  32. </bean>  
  33.   
  34. <!-- 配置第二个数据源-->  
  35. <bean id="dataSourceB" parent="abstractXADataSource">  
  36.     <!-- value只要两个数据源不同就行，随便取名 -->  
  37.     <property name="uniqueResourceName" value="mysql/sitesttwo" />  
  38.     <property name="xaDataSourceClassName"  
  39.         value="com.mysql.jdbc.jdbc2.optional.MysqlXADataSource" />  
  40.     <property name="xaProperties">  
  41.         <props>  
  42.             <prop key="URL">${jdbca.url}</prop>  
  43.             <prop key="user">${jdbca.username}</prop>  
  44.             <prop key="password">${jdbca.password}</prop>  
  45.         </props>  
  46.     </property>  
  47. </bean>  
taozhe666
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Boot+Druid+Mybatis实现JTA分布式事务
08-27
Spring Boot+Druid+Mybatis实现JTA分布式事务
Spring|Spring的事务 事务管理器
YvesHe的专栏
07-01 4544
文章目录9.2.1 概述9.2.2 内置事务管理器实现一、声明对本地事务的支持：二、Spring对全局事务的支持： 9.2.1 概述 Spring框架支持事务管理的核心是事务管理器抽象，对于不同的数据访问框架（如Hibernate）通过实现策略接口PlatformTransactionManager，从而能支持各种数据访问框架的事务管理，PlatformTransactionManag...
Spring全局事务之JTA+Atomikos
rj042的专栏
03-20 1815
本文简单介绍一下在Spring通过声明管理一个有数据库和ActiveMQ参入的全局事务,事务管理器的实现为Atomikos.全局事务的步骤为 1,更新数据库操作. 2访问ActiveMQ资源. 3,提交在数据库A中的操作. 4,提交在ActiveMQ中的操作. 上面的所有步骤应该保证要么全部成功,要么全部回滚.下面是实现的步骤: 1,配置Spring文件: [ht
使用Spring和Atomikos集成JTA分布式事务
MassiveStars的博客
01-04 2056
分布式事务 分布式事务是指事务位于不同的分布式系统的不同节点之上。目的是保证分布式系统事务的原子性和一致性。XA规范是由X/Open DTP提出的分布式事务规范。XA规范包含四大角色：应用程序( AP )事务管理器( TM )资源管理器( RM )通信资源管理器( CRM )常见的事务 管理器( TM )是交易中间件,常见的资源管理器( RM )是数据库,常见的通信资源管理器( CRM )是消息
spring结合 atomikos 使用
L-BAKE
02-10 1197
atomikos 所需jar : 1.transactions-jdbc.jar 2.transactions.jar 3.transactions-jta.jar 4.transactions-api.jar 5.atomikos-util.jar jta.properties 配置文件 放在src目录即可 com.atomikos.icatch.s
spring + JTA + JOTM实现分布式事务
09-21
spring + JTA + JOTM实现分布式事务， 高大上的技术
REST微服务的分布式事务实现-分布式系统、事务以及JTA介绍
01-27
在介绍分布式事务之前，先来来回顾一下事务的ACID原则：原子性（A）：原子性是指一个事务的所有操作，要么都做完，要么都不做。 一致性（C）：一致性是指一个事务的执行，不管外部环境如何，不管怎么执行，结果应该...
spring 结合druid和hibernate使用jta配置分布式事务
10-31
atomikos实现多数据源支持分布式事务管理（spring、tomcat、JTA） 结合spring 和durid进行配置，
JTA transaction unexpectedly rolled back (maybe due to a timeout)； 解决方法
qq_43304719的博客
11-22 6389
JTA transaction unexpectedly rolled back (maybe due to a timeout); nested exception is javax.transaction.RollbackException: One or more resources refused to commit (possibly because of a timeout in the resource - see the log for details). This transaction
在Spring中使用JTA事务管理
11-24 313
Spring 通过AOP技术可以让我们在脱离EJB的情况下享受声明式事务的丰盛大餐，脱离Java EE应用服务器使用声明式事务的道路已经畅通无阻。但是很大部分人都还认为脱离Java EE应用服务器就无法使用JTA事务，这是一个误解。其实，通过配合使用ObjectWeb的JOTM开源项目，不需要Java EE应用服务器，Spring也可以提供JTA事务。 正因为AOP让Spring...
使用JTA的事务处理(pro spring ch12范例)问题
wolf_jack的专栏
01-12 258
在实施中12章多事务处理范例遇到问题,当指定由JTA管理的事务执行时,相关代码进入异常抛出部分: TestControl.java ... try { accountManager.insert(account); } catch (Exception ex) { failures++; } ... 每次insert都失败,failures值增加.原代码insert部分如下 ...
SpringMVC之WebLogicJtaTransactionManager实现全局事务管理
崔向阳@李晓的博客
11-19 1247
背景描述：随着应用系统复杂度越来越复杂，之前在一个库中完成所有业务操作已不满足现状业务系统的要求，数据流转往往存在于多个库中进行，全局事务是指在一个事务中涉及到几个事务参入者,这些事务参入者可以是我们常见的数据库操作,消息(MQ)操作等等.如同时进行下面的操作,比如"转账"操作发生在两个数据库: 1,从数据库A的的表中将某个帐号的余额减少. 2从数据库B的的表中将某个帐号的余额增加. 3,提交在数...
JTA事务原理深度历险
ylq2250的专栏
08-12 419
转载：http://www.ibm.com/developerworks/cn/java/j-lo-jta/ 利用 JTA 处理事务 什么是事务处理 事务是计算机应用中不可或缺的组件模型，它保证了用户操作的原子性 ( Atomicity )、一致性 ( Consistency )、隔离性 ( Isolation ) 和持久性 ( Durabilily )。关于事务最经典的示例莫过于信用...
|JTA|atomikos 连接超时设置
myth_g的博客
04-02 2411
@Bean @Primary public JtaTransactionManager jtaTransactionManager() throws SystemException { UserTransactionImp userTransactionImp = new UserTransactionImp(); userTransact...
使用JTA解决多数据源事务问题
旷野历程
04-11 2107
分享知识 传递快乐 在一些复杂的应用开发中，一个应用可能会涉及到连接多个数据源，所谓多数据源可以简单理解为至少连接两个及以上的数据库。在动手之前最好先了解对JTA有个了解，可参考：浅谈 JTA 事务 项目环境 springboot 2.3.1 mybatis plus jta 项目依赖 pom.xml中关键依赖 <dependency> <groupId>org.springframework.boot</groupId> &...
spring+mybatis+Atomikos JTA事务配置说明
xiaohuanxiong6616的专栏
10-16 370
一、概览 Atomikos是一个公司名字，旗下最著名的莫过于其Atomikos的事务管理器产品。产品分两个：一个是开源的TransactionEssentials，一个是商业的ExtremeTransactions。 TransactionEssentials的主要特征： JTA/XA 事务管理 —— 提供事务管理和连接池 不需要应用服务器 —— TransactionEssenti...
Spring-Boot java事务回滚异常“JTA transaction unexpectedly rolled back (maybe due to a timeout); nested”
热门推荐
天线婊婊的博客
10-26 2万+
“JTA transaction unexpectedly rolled back (maybe due to a timeout); nested”异常解决在公司开发的时候遇到了一个事务问题。看原因吧说事务回滚了，可能是超时导致的，确实是超时，尼玛我好几千大军加载不出来了，测试小姐姐限我10分钟解决bug，不然我可能会死，我硬生生搞了一下午都没找到解决方案，心好累，10分钟全部用来心疼自己了。加上
spring分布式事务的实现
最新发布
05-10
5. 如果需要在分布式事务中进行消息队列的操作，可以使用 Spring 提供的 JmsTemplate 来发送和接收消息，并使用 @Transactional 注解来实现分布式事务的管理。 总的来说，Spring 分布式事务的实现需要结合具体的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值