Spring分布式事务实现

       分布式事务是指操作多个数据库之间的事务，spring的org.springframework.transaction.jta.JtaTransactionManager，提供了分布式事务支持。如果使用WAS的JTA支持，把它的属性改为WebSphere对应的TransactionManager。 
       在tomcat下，是没有分布式事务的，不过可以借助于第三方软件jotm（Java Open Transaction Manager ）和AtomikosTransactionsEssentials实现，在spring中分布式事务是通过jta（jotm，atomikos）来进行实现。 
1、http://jotm.objectweb.org/ 
2、http://www.atomikos.com/Main/TransactionsEssentials 

一、使用JOTM例子 
(1) Dao及实现 

GenericDao接口：

[java] view plaincopyprint?

1. public interface GenericDao {  
2.     public int save(String ds, String sql, Object[] obj) throws Exception;    
3.     public int findRowCount(String ds, String sql);   
4. }  

GenericDaoImpl 实现：

[java] view plaincopyprint?

1. public class GenericDaoImpl implements GenericDao{  
2.   
3.     private  JdbcTemplate jdbcTemplateA;  
4.     private  JdbcTemplate jdbcTemplateB;  
5.   
6.     public void setJdbcTemplateA(JdbcTemplate jdbcTemplate) {  
7.         this.jdbcTemplateA = jdbcTemplate;  
8.     }  
9.   
10.     public void setJdbcTemplateB(JdbcTemplate jdbcTemplate) {  
11.         this.jdbcTemplateB = jdbcTemplate;  
12.     }  
13.       
14.     public int save(String ds, String sql, Object[] obj) throws Exception{  
15.         if(null == ds || "".equals(ds)) return -1;  
16.         try{  
17.             if(ds.equals("A")){  
18.                 return this.jdbcTemplateA.update(sql, obj);  
19.             }else{  
20.                 return this.jdbcTemplateB.update(sql, obj);  
21.             }  
22.         }catch(Exception e){  
23.             e.printStackTrace();  
24.             throw new Exception("执行" + ds + "数据库时失败！");  
25.         }  
26.     }  
27.   
28.     public int findRowCount(String ds, String sql) {  
29.         if(null == ds || "".equals(ds)) return -1;  
30.           
31.         if(ds.equals("A")){  
32.             return this.jdbcTemplateA.queryForInt(sql);  
33.         }else{  
34.             return this.jdbcTemplateB.queryForInt(sql);  
35.         }  
36.     }  
37. }  

 

(2) Service及实现 

 

UserService 接口：

[java] view plaincopyprint?

1. public interface UserService {  
2.     public void saveUser() throws Exception;  
3. }  

UserServiceImpl 实现：

[java] view plaincopyprint?

1. public class UserServiceImpl implements UserService{  
2.   
3.     private GenericDao genericDao;  
4.       
5.     public void setGenericDao(GenericDao genericDao) {  
6.         this.genericDao = genericDao;  
7.     }  
8.   
9.     public void saveUser() throws Exception {  
10.         String userName = "user_" + Math.round(Math.random()*10000);  
11.         System.out.println(userName);  
12.           
13.         StringBuilder sql = new StringBuilder();  
14.         sql.append(" insert into t_user(username, gender) values(?,?); ");  
15.         Object[] objs = new Object[]{userName,"1"};  
16.           
17.         genericDao.save("A", sql.toString(), objs);  
18.           
19.         sql.delete(0, sql.length());  
20.         sql.append(" insert into t_user(name, sex) values(?,?); ");  
21.         objs = new Object[]{userName,"男的"};//值超出范围  
22.         genericDao.save("B", sql.toString(), objs);  
23.     }  
24. }  

 

(3) applicationContext-jotm.xml 

[java] view plaincopyprint?

1. "1.0" encoding="UTF-8"?>  
2. "http://www.springframework.org/schema/beans"   
3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
4.     xmlns:context="http://www.springframework.org/schema/context"   
5.     xmlns:aop="http://www.springframework.org/schema/aop"   
6.     xmlns:tx="http://www.springframework.org/schema/tx"   
7.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd   
8.     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd   
9.     http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd   
10.     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">  
11.   
12.     springJTA  
13.   
14.        
15.     "propertyConfig"   
16.             class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">   
17.         "locations">   
18.                
19.                 classpath:jdbc.properties   
20.                
21.            
22.        
23.       
24.       
25.     "jotm" class="org.springframework.transaction.jta.JotmFactoryBean">  
26.           "defaultTimeout" value="500000"/>  
27.       
28.   
29.       
30.     "jtaTransactionManager" class="org.springframework.transaction.jta.JtaTransactionManager">     
31.         "userTransaction" ref="jotm" />     
32.       
33.   
34.        
35.     "dataSourceA" class="org.enhydra.jdbc.pool.StandardXAPoolDataSource" destroy-method="shutdown">   
36.        "dataSource">   
37.            class="org.enhydra.jdbc.standard.StandardXADataSource" destroy-method="shutdown">   
38.                "transactionManager" ref="jotm"/>   
39.                "driverName" value="${jdbc.driver}"/>   
40.                "url" value="${jdbc.url}"/>   
41.               
42.           
43.        "user" value="${jdbc.username}"/>   
44.        "password" value="${jdbc.password}"/>   
45.        
46.   
47.        
48.     "dataSourceB" class="org.enhydra.jdbc.pool.StandardXAPoolDataSource" destroy-method="shutdown">   
49.        "dataSource">   
50.            class="org.enhydra.jdbc.standard.StandardXADataSource" destroy-method="shutdown">   
51.                "transactionManager" ref="jotm"/>   
52.                "driverName" value="${jdbc2.driver}"/>   
53.                "url" value="${jdbc2.url}"/>   
54.               
55.           
56.        "user" value="${jdbc2.username}"/>   
57.        "password" value="${jdbc2.password}"/>   
58.        
59.   
60.     "jdbcTemplateA"   
61.          class = "org.springframework.jdbc.core.JdbcTemplate">   
62.          "dataSource" ref="dataSourceA"/>   
63.       
64.       
65.     "jdbcTemplateB"   
66.          class = "org.springframework.jdbc.core.JdbcTemplate">   
67.          "dataSource" ref="dataSourceB"/>   
68.           
69.   
70.        
71.        
72.         "pointCut"  
73.                 expression="execution(* com.logcd.service..*.*(..))"/>  
74.         "pointCut" advice-ref="txAdvice"/>   
75.           
76.         "execution(* *..common.service..*.*(..))" advice-ref="txAdvice"/>  
77.        
78.   
79.        
80.     "txAdvice" transaction-manager="jtaTransactionManager">   
81.           
82.           "delete*" rollback-for="Exception"/>   
83.           "save*" rollback-for="Exception"/>   
84.           "update*" rollback-for="Exception"/>   
85.           "find*" read-only="true" rollback-for="Exception"/>   
86.           
87.        
88.   
89.     "genericDao"  class="com.logcd.dao.impl.GenericDaoImpl" autowire="byName">   
90.     "userService"  class="com.logcd.service.impl.UserServiceImpl" autowire="byName">   
91.   

 

(4) 测试 

[java] view plaincopyprint?

1. public class TestUserService{  
2.   
3.     private static UserService userService;  
4.       
5.     @BeforeClass  
6.     public static void init(){  
7.         ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext-jotm.xml");  
8.         userService = (UserService)app.getBean("userService");  
9.     }  
10.       
11.     @Test  
12.     public void save(){  
13.         System.out.println("begin...");  
14.         try{  
15.             userService.saveUser();  
16.         }catch(Exception e){  
17.             System.out.println(e.getMessage());  
18.         }  
19.         System.out.println("finish...");  
20.     }  
21. }  

 

 

二、关于使用atomikos实现 
(1) 数据源配置 

 

 

[java] view plaincopyprint?

1. "dataSourceA" class="com.atomikos.jdbc.SimpleDataSourceBean" init-method="init" destroy-method="close">  
2.     "uniqueResourceName">  
3.         ${datasource.uniqueResourceName}  
4.       
5.     "xaDataSourceClassName">   
6.         ${database.driver_class}   
7.        
8.     "xaDataSourceProperties">  
9.         URL=${database.url};user=${database.username};password=${database.password}   
10.        
11.     "exclusiveConnectionMode">   
12.         ${connection.exclusive.mode}   
13.       
14.     "connectionPoolSize">   
15.         ${connection.pool.size}  
16.       
17.     "connectionTimeout">  
18.         ${connection.timeout}  
19.       
20.     "validatingQuery">   
21.         SELECT 1   
22.        
23.   

(2)、事务配置 

 

[java] view plaincopyprint?

1. "atomikosTransactionManager" class="com.atomikos.icatch.jta.UserTransactionManager"   
2.     init-method="init" destroy-method="close">   
3.     "forceShutdown" value="true"/>   
4.    
5.   
6. "atomikosUserTransaction" class="com.atomikos.icatch.jta.UserTransactionImp">   
7.     "transactionTimeout" value="${transaction.timeout}"/>   
8.   
9.   
10.    
11. "springTransactionManager" class="org.springframework.transaction.jta.JtaTransactionManager">   
12.     "transactionManager" ref="atomikosTransactionManager"/>   
13.     "userTransaction" ref="atomikosUserTransaction"/>   
14.   
15.   
16.    
17.    
18.     "serviceOperation"  expression="execution(* *..service*..*(..))"/>   
19.     "serviceOperation" advice-ref="txAdvice"/>   
20.   
21.   
22.   
23. "txAdvice" transaction-manager="springTransactionManager">   
24.       
25.         "*" rollback-for="Exception"/>   
26.        
27.    

 

 

有关JTA
JTA全称为Java Transaction API，顾名思义JTA定义了一组统一的事务编程的接口，这些接口如下：
 
XAResource 
XAResource接口是对实现了X/Open CAE规范的资源管理器 (Resource Manager，数据库就是典型的资源管理器) 的抽象，它由资源适配器 (Resource Apdater) 提供实现。XAResource是支持事务控制的核心。

Transaction
Transaction接口是一个事务实例的抽象，通过它可以控制事务内多个资源的提交或者回滚。二阶段提交过程也是由Transaction接口的实现者来完成的。
 

 

 

TransactionManager
托管模式 (managed mode) 下，TransactionManager接口是被应用服务器调用，以控制事务的边界的。
 
UserTransaction
非托管模式 (non-managed mode) 下，应用程序可以通过UserTransaction接口控制事务的边界
 
托管模式下的事务提交场景

注意：在上图中3和5的步骤之间省略了应用程序对资源的操作 (如CRUD)。另外，应用服务器什么时机 enlistResource，又是什么时候delistResource呢？这在后文中会解释。

 

有关JCA

下图为JCA的架构图

中间涉及元素说明如下：
1）Enterprise Information System
简称EIS，在JTA中它又被称为资源管理器。典型的EIS有数据库，事务处理系统(Transaction Processing System)，ERP系统。
 
2）Resource Adapter
资源适配器(Resource Adaper)是JCA的关键。要想把不同的EIS整合(或者连接)到J2EE运行环境中，就必须为每个EIS提供资源适配器，它会将将EIS适配为一个具备统一编程接口的资源 (Resource) 。这个统一编程接口就是上图中的System Contracts和Client API。下面的UML类图将完美诠释资源适配器。

 

3）Application Server
应用服务器 (Application Server) 通过System Contracts来管理对EIS的安全、事务、连接等。典型的应用服务器有JBoss、JOnAS、Geronimo、GlassFish等。
 
4）Application Component 
应用组件 (Application Component) ，它封装了应用业务逻辑，像对资源的访问和修改。典型的应用组件就是EJB。
 
更多细节请参见：
Sun Microsystems Inc.J2EE Connector Architecture 1.5 

 

 

参考推荐：

Spring分布式事务实现

JTA与JCA分布式事务

理解 JCA 事务（IBM）

Jencks实现Hibernate与Jackrabbit的分布式事务