关于分布式事务

标签： 分布 | 发表时间：2013-12-05 15:20 | 作者：fengbin2005
出处：http://www.iteye.com

 

 

Mysql当前分布式事务只支持Innodb存储引擎。1个分布式事务由多个行为在不同的数据库上执行，1个分布式事务的执行成功意味着相关数据库上的行为执行均成功。

使用分布式事务的应用程序设计1个或多个资源管理器和一个事务管理器。
资源管理器(RM):用户提供通向事务的途径。数据库服务器是一个种资源管理器。该管理器必须提交or回滚由RM管理的事务。
事务管理器(TM):用于协调作为一个分布式事务的一部分事务。

要执行一个分布式事务，必须知道这个分布式事涉及了哪些资源管理器，并且把每个资源管理器的事务执行到事务可以被提交或回滚。根据每个资源管理报告的有关的执行情况的内容，这些分支事务必须作为一个原子性操作全部提交或回滚。

用于执行分布式事务的过程使用两阶段提交，发生时间在由分布式事务的各个分支需要进行的行动已经被执行之后。
 
在第一阶段，所有的分支都预备好。他们被TM告知要准备提交。用于管理分支的每个RM会记录对于被稳定保存的分支的行动。分支指示是否他们可以这么做。这些结果被用于第二阶段。
 

在第二阶段，TM告知RMs是否要提交或回滚。如果在预备分支时，所有的分支指示他们将能够提交，则所有的分支被告知要提交。如果在预备时，有任何分支指示它将不能提交，则所有分支被告之回滚。

分布式的语法：
XA START xid ，用来唯一标识一个分布式事务。
XA END xid
XA PRERARE xid
XA COMMIT xid
XA ROLLBACK xid
XA RECOVER



 

 

--------------------分布式事务详解--------------------------

  分布式事务是指操作多个数据库之间的事务，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接口：

  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 实现：

  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 接口：

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

UserServiceImpl 实现：

  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

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="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.     <description>springJTA</description>  
  13.   
  14.     <!--指定Spring配置中用到的属性文件-->   
  15.     <bean id="propertyConfig"   
  16.             class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">   
  17.         <property name="locations">   
  18.             <list>   
  19.                 <value>classpath:jdbc.properties</value>   
  20.             </list>   
  21.         </property>   
  22.     </bean>   
  23.       
  24.     <!-- JOTM实例 -->  
  25.     <bean id="jotm" class="org.springframework.transaction.jta.JotmFactoryBean">  
  26.           <property name="defaultTimeout" value="500000"/>  
  27.     </bean>  
  28.   
  29.     <!-- JTA事务管理器 -->  
  30.     <bean id="jtaTransactionManager" class="org.springframework.transaction.jta.JtaTransactionManager">     
  31.         <property name="userTransaction" ref="jotm" />     
  32.     </bean>  
  33.   
  34.     <!-- 数据源A -->   
  35.     <bean id="dataSourceA" class="org.enhydra.jdbc.pool.StandardXAPoolDataSource" destroy-method="shutdown">   
  36.        <property name="dataSource">   
  37.            <bean class="org.enhydra.jdbc.standard.StandardXADataSource" destroy-method="shutdown">   
  38.                <property name="transactionManager" ref="jotm"/>   
  39.                <property name="driverName" value="${jdbc.driver}"/>   
  40.                <property name="url" value="${jdbc.url}"/>   
  41.            </bean>   
  42.        </property>   
  43.        <property name="user" value="${jdbc.username}"/>   
  44.        <property name="password" value="${jdbc.password}"/>   
  45.     </bean>   
  46.   
  47.     <!-- 数据源B -->   
  48.     <bean id="dataSourceB" class="org.enhydra.jdbc.pool.StandardXAPoolDataSource" destroy-method="shutdown">   
  49.        <property name="dataSource">   
  50.            <bean class="org.enhydra.jdbc.standard.StandardXADataSource" destroy-method="shutdown">   
  51.                <property name="transactionManager" ref="jotm"/>   
  52.                <property name="driverName" value="${jdbc2.driver}"/>   
  53.                <property name="url" value="${jdbc2.url}"/>   
  54.            </bean>   
  55.        </property>   
  56.        <property name="user" value="${jdbc2.username}"/>   
  57.        <property name="password" value="${jdbc2.password}"/>   
  58.     </bean>   
  59.   
  60.     <bean id = "jdbcTemplateA"   
  61.          class = "org.springframework.jdbc.core.JdbcTemplate">   
  62.          <property name = "dataSource" ref="dataSourceA"/>   
  63.     </bean>  
  64.       
  65.     <bean id = "jdbcTemplateB"   
  66.          class = "org.springframework.jdbc.core.JdbcTemplate">   
  67.          <property name = "dataSource" ref="dataSourceB"/>   
  68.     </bean>      
  69.   
  70.     <!-- 事务切面配置 -->   
  71.     <aop:config>   
  72.         <aop:pointcut id="pointCut"  
  73.                 expression="execution(* com.logcd.service..*.*(..))"/><!-- 包及其子包下的所有方法 -->  
  74.         <aop:advisor pointcut-ref="pointCut" advice-ref="txAdvice"/>   
  75.           
  76.         <aop:advisor pointcut="execution(* *..common.service..*.*(..))" advice-ref="txAdvice"/>  
  77.     </aop:config>   
  78.   
  79.     <!-- 通知配置 -->   
  80.     <tx:advice id="txAdvice" transaction-manager="jtaTransactionManager">   
  81.        <tx:attributes>   
  82.           <tx:method name="delete*" rollback-for="Exception"/>   
  83.           <tx:method name="save*" rollback-for="Exception"/>   
  84.           <tx:method name="update*" rollback-for="Exception"/>   
  85.           <tx:method name="find*" read-only="true" rollback-for="Exception"/>   
  86.        </tx:attributes>   
  87.     </tx:advice>   
  88.   
  89.     <bean id="genericDao"  class="com.logcd.dao.impl.GenericDaoImpl" autowire="byName"> </bean>  
  90.     <bean id="userService"  class="com.logcd.service.impl.UserServiceImpl" autowire="byName"> </bean>  
  91. </beans>  

 

(4) 测试

  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) 数据源配置

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


(2)、事务配置

  1. <bean id="atomikosTransactionManager" class="com.atomikos.icatch.jta.UserTransactionManager"   
  2.     init-method="init" destroy-method="close">   
  3.     <property name="forceShutdown" value="true"/>   
  4. </bean>   
  5.   
  6. <bean id="atomikosUserTransaction" class="com.atomikos.icatch.jta.UserTransactionImp">   
  7.     <property name="transactionTimeout" value="${transaction.timeout}"/>   
  8. </bean>  
  9.   
  10. <!-- JTA事务管理器 -->   
  11. <bean id="springTransactionManager" class="org.springframework.transaction.jta.JtaTransactionManager">   
  12.     <property name="transactionManager" ref="atomikosTransactionManager"/>   
  13.     <property name="userTransaction" ref="atomikosUserTransaction"/>   
  14. </bean>  
  15.   
  16. <!-- 事务切面配置 -->   
  17. <aop:config>   
  18.     <aop:pointcut id="serviceOperation"  expression="execution(* *..service*..*(..))"/>   
  19.     <aop:advisor pointcut-ref="serviceOperation" advice-ref="txAdvice"/>   
  20. </aop:config>  
  21.   
  22. <!-- 通知配置 -->  
  23. <tx:advice id="txAdvice" transaction-manager="springTransactionManager">   
  24.     <tx:attributes>  
  25.         <tx:method name="*" rollback-for="Exception"/>   
  26.     </tx:attributes>   
  27. </tx:advice>   



有关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 

 

 

http://www.ibm.com/developerworks/cn/java/j-lo-jta/

http://blog.csdn.net/ithomer/article/details/10859235

http://liuhaodba.blog.51cto.com/6379925/1117647

http://hedengcheng.com/?p=136



已有 0 人发表留言，猛击->> 这里<<-参与讨论


ITeye推荐



相关 [分布] 推荐：

分布式日志

- - Java - 编程语言 - ITeye博客
最近完成一个简单的日志管理系统，拿出来跟大家分享一下. 3、支持文件输出、habse输出、mongodb输出. 基于以上三点功能，我们下面详细说明. 说道支持这个功能，有个同事认为没有这个必要，他的观点是log4j的配置不需要经常变动，不需要支持这样的功能；本人的观点是“配置可以进行统一管理、而且正式机跟测试机的log4j的配置肯定会有一些差异的”，因此这个功能是必须的.

分布式事务简述

- If you are thinking one year ahead, you plant rice. If you are thinking twenty years ahead, you plant trees. If you are thinking a hundred years ahead, you educate people. - BlogJava-首页技术区
  随着系统越来越大，不断的模块化和SOA化，你的系统可能被分散于不同的机器上，这时候，你原先的单机本地事务可能已经无法满足你的需求，你可能要跨系统跨资源的去使用事务.   具体就不多介绍了，相信大家都能明白ACID特性的基本含义. 而一个具体的事务需要涉及到的模型（无论哪种模型）一般由下面几部分组成：.

Hadoop与分布式计算

- 透明 - 丕子
写本文由leftnoteasy发布于http://leftnoteasy.cnblogs.com 本文可以被全部或者部分的使用，但请注明出处，如果有问题，可以联系wheeleast (at) gmail.com, 也可以加作者的新浪微博：http://weibo.com/leftnoteasy. 很久没有写写博客了，之前主要是换工作，耽误了很多的时间，让人也变得懒散，不想花大时间来写东西.

分布式缓存-Memcached

- - 人月神话的BLOG
分布式缓存出于如下考虑，首先是缓存本身的水平线性扩展问题，其次是缓存大并发下的本身的性能问题，再次避免缓存的单点故障问题(多副本和副本一致性). 分布式缓存的核心技术包括首先是内存本身的管理问题，包括了内存的分配，管理和回收机制. 其次是分布式管理和分布式算法，其次是缓存键值管理和路由. 原文： http://wenku.baidu.com/view/8686d46c7e21af45b307a8c3.html.

再谈集中和分布

- - 人月神话的BLOG
上篇文章转载了关于mysql数据库的垂直和水平拆分的相关内容，本篇文章再谈下关于应用集中化后的集中和分布相关策略问题，以及最近关于完全去IOE思路的一些思考和回顾. 现在有一个问题我暂时还没得到比较明确的一些验证，如对于当前x86的pc server服务器好的配置完全可以达到200万TPMC，对于磁盘阵列可以挂接到20T甚至更高的存储容量.

hadoop分布式配置

- - CSDN博客云计算推荐文章
一、前面的部分见伪分布式配置. 二、实现SSH无密码登录远程主机（只在源主机上配置）. 注意：以上scp命令表示把authoriezd_keys远程复制到对应主机的相应目录下. slave2是目的主机的名字，需要在源主机的/etc/hosts下配置slave2以及对应的IP地址 192.168.0.5.

浅谈分布式缓存

- - CSDN博客推荐文章
在前面的一些文章中，从实战的角度，讲解了有关 memcached的应用、容灾、监控等等. 但是缺乏对理论的讲解和原理性的剖析. 本文将从理论的角度去介绍，让大家从宏观上对“分布式缓存、nosql”等技术有所了解，以便进一步学习和使用. 在构建大规模的web应用时，缓存技术可以说是必备的，学习的必要性不言而喻.

关于分布式事务

- - Web前端 - ITeye博客
Mysql当前分布式事务只支持Innodb存储引擎. 1个分布式事务由多个行为在不同的数据库上执行，1个分布式事务的执行成功意味着相关数据库上的行为执行均成功. 使用分布式事务的应用程序设计1个或多个资源管理器和一个事务管理器. 资源管理器(RM):用户提供通向事务的途径. 数据库服务器是一个种资源管理器.

BDRP分布式redis集群

- - 百度运维团队技术博客
BDRP（baidu distributed redis platform）是包含 twemproxy， redis，redis-sentinel等多个模块开发的分布式redis平台. bdrp已经在github上进行了开源， bdrp的github项目点这里. 目前redis集群架构主要有以下几个组件： twemproxy：redis的代理系统，可以选择多种数据分片算法 redis：集群的redis存储节点 sentinel：redis官方的集群高可用组件，可以监控redis主节点故障，并进行主备切换.

分布式搜索算法

- - 杨尚川的个人页面
对于搜索引擎来说，索引存放在成千上万台机器上，如何进行分布式搜索呢. 假设搜索结果是以分页的方式显示，以PageNumber代表当前页，从1开始，以PageSize代表页面大小，默认为10，以N代表搜索服务器数量. 最简单的分布式搜索算法为：有一台 合并服务器负责接受用户的搜索请求，然后分别向N台机器获取前PageNumber*PageSize条结果，得到的结果数为N*PageNumber*PageSize，然后把这些数据重新进行排序，根据所要显示的页面PageNumber，获取从(PageNumber - 1) * PageSize + 1开始的PageSize条结果返回给用户.