分布式事务系列(3.1)jotm的分布式案例

原创
2015/05/25 06:57
阅读数 8.8K

#1 系列目录

#2 与Spring集成方式使用jotm

工程代码地址:与Spring集成方式使用jotm

先来感受下一个分布式事务的案例(使用一般的数据库驱动,不需要支持分布式XA协议):

##2.1 业务逻辑的操作

UserDao和LogDao,操作分别如下:

@Repository
public class UserDao {

	@Resource(name="jdbcTemplateA")
	private JdbcTemplate jdbcTemplate;
	
	public void save(User user){
		jdbcTemplate.update("insert into user(name,age) values(?,?)",user.getName(),user.getAge());
	}
}

@Repository
public class LogDao {

	@Resource(name="jdbcTemplateB")
	private JdbcTemplate jdbcTemplate;
	
	public void save(User user){
		jdbcTemplate.update("insert into log(name,age) values(?,?)",user.getName(),user.getAge());
	}
}

即上述两个JdbcTemplate使用不同的数据库。

UserService综合上述两个业务操作,使它们处于同一个事务中:

[@Service](http://my.oschina.net/service)
public class UserService {
	
	@Autowired
	private UserDao userDao;
	@Autowired
	private LogDao logDao;
	
	@Transactional
	public void save(User user){
		userDao.save(user);
		logDao.save(user);
		throw new RuntimeException();
	}
}

##2.2 配置

上述业务代码我们看不到分布式事务的存在,这种正是我们想要的效果,分布式事务对业务透明。到底是如何来实现呢?

###2.2.1 dataSource和JdbcTemplate配置

 <bean id="dataSourceA" class="org.enhydra.jdbc.pool.StandardXAPoolDataSource"  destroy-method="shutdown">
 	<property name="dataSource">  
        <bean class="org.enhydra.jdbc.standard.StandardXADataSource" destroy-method="shutdown">  
            <property name="transactionManager" ref="jotm" />  
            <property name="driverName" value="com.mysql.jdbc.Driver" />  
            <property name="url" value="jdbc:mysql://localhost:3306/test?useUnicode=true&amp;characterEncoding=utf-8" />  
        </bean>  
    </property>     
    <property name="user" value="root" />  
    <property name="password" value="xxxxx" />  
</bean>

 <bean id="dataSourceB"   class="org.enhydra.jdbc.pool.StandardXAPoolDataSource"  destroy-method="shutdown">   
    <property name="dataSource">  
        <bean class="org.enhydra.jdbc.standard.StandardXADataSource" destroy-method="shutdown">  
            <property name="transactionManager" ref="jotm" />  
            <property name="driverName" value="com.mysql.jdbc.Driver" />  
            <property name="url" value="jdbc:mysql://localhost:3306/test2?useUnicode=true&amp;characterEncoding=utf-8" />  
        </bean>  
    </property>     
    <property name="user" value="root" />  
    <property name="password" value="xxxx" /> 
</bean>

自行配置2个数据库地址

我们平常使用的dataSource,大部分是c3p0、dbcp等,这里就不能使用它们了,需要换成可以模拟XA协议的dataSource,即StandardXAPoolDataSource。这个连接池是xapool提供的。

顺便简单介绍下xapool官网地址:

  • 它设计了一个GenericPool,这个pool里面可以存放任何Object
  • 它提供了dataSource的实现,同时还提供了针对分布式的dataSource即StandardXAPoolDataSource,它可以通过使用普通的数据库驱动来模拟两阶段提交协议中XAResource的作用。本来XAResource是需要由数据库XA驱动来实现的。
  • 不过好久都没更新了,官网上最近一次更新还是06年

之后再详细介绍它的源码内容。

###2.2.2 事务配置

我们知道分布式事务中需要一个事务管理器即接口javax.transaction.TransactionManager、面向开发人员的javax.transaction.UserTransaction。对于jotm来说,他们的实现类都是Current,如下源码所示:

public class Current implements UserTransaction, TransactionManager

我们如果想使用分布式事务的同时,又想使用Spring带给我们的@Transactional便利,就需要配置一个JtaTransactionManager,而该JtaTransactionManager是需要一个userTransaction实例的,所以用到了上面的Current,如下配置:

<bean id="jotm" class="org.objectweb.jotm.Current" />

<bean id="transactionManager" class="org.springframework.transaction.jta.JtaTransactionManager">  
    <property name="userTransaction" ref="jotm" />  
</bean>

<tx:annotation-driven transaction-manager="transactionManager"/>

同时上述StandardXADataSource是需要一个TransactionManager实例的,所以上述StandardXADataSource配置把jotm加了进去

###2.2.3 jar包依赖

整个工程主要是利用jotm和xapool来实现分布式事务。jotm提供事务管理器javax.transaction.TransactionManager和面向开发人员的功能接口javax.transaction.UserTransaction,而xapool则是对非XA数据库驱动进行包装,来模拟XA数据库驱动干的事。所以依赖的pom如下:

<!-- jotm -->
<dependency>
	<groupId>org.ow2.jotm</groupId>
	<artifactId>jotm-core</artifactId>
	<version>2.3.1-M1</version>
</dependency>  
<dependency>
	<groupId>org.ow2.jotm</groupId>
	<artifactId>jotm-datasource</artifactId>
	<version>2.3.1-M1</version>
</dependency>

<!-- xapool -->
<dependency>
	<groupId>com.experlog</groupId>
	<artifactId>xapool</artifactId>
	<version>1.5.0</version>
</dependency>

上述jotm-datasource主要是为了将上述StandardXAPoolDataSource数据源放置到容器中,如tomcat,而不是应用程序中。应用程序通过JNDI的方式从tomcat容器中获取上述数据源。所以对于本工程来说可以不要,对于下文说的通过JNDI方式使用jotm则是必须的

##2.3 分布式事务执行的大致过程

下面先粗略的说明下分布式事务的大致执行过程,即下面的执行过程:

@Transactional
public void save(User user){
    userDao.save(user);
    logDao.save(user);
    throw new RuntimeException();
}
  • 第一步:事务拦截器开启事务

    我们知道加入了@Transactional注解,同时开启tx:annotation-driven,会对本对象进行代理,加入事务拦截器。在事务拦截器中,获取javax.transaction.UserTransaction,这里即org.objectweb.jotm.Current,然后使用它开启事务,并和当前线程进行绑定,绑定关系数据存放在org.objectweb.jotm.Current中

  • 第二步:使用jdbcTemplate进行业务操作

    jdbcTemplateA要从dataSourceA中获取Connection,和当前线程进行绑定,同时以对应的dataSourceA作为key。同时判断当前线程是否含有事务,通过dataSourceA中的org.objectweb.jotm.Current发现当前线程有事务,则把Connection自动提交设置为false,同时将该连接纳入当前事务中。

    jdbcTemplateB要从dataSourceB中获取Connection,和当前线程进行绑定,同时以对应的dataSourceB作为key。同时判断当前线程是否含有事务,通过dataSourceB中的org.objectweb.jotm.Current发现当前线程有事务,则把Connection自动提交设置为false,同时将该连接纳入当前事务中。

  • 第三步:

    一旦抛出异常,则需要进行事务的回滚操作。回滚就是将当前事务进行回滚,该事务的回滚会调用和它关联的所有Connection的回滚。

这里再举一个简单的例子,如下:

Connection connA=dataSourceA.getConnection();
Connection connB=dataSourceB.getConnection();

Statement statementA=connA.createStatement();
Statement statementB=connB.createStatement();

String sql="insert into user(name,age) values('"+user.getName()+"',"+user.getAge()+")";

try {
	connA.setAutoCommit(false);
	connB.setAutoCommit(false);
	
	statementA.execute(sql);
	statementB.execute(sql);
	
	//throw new RuntimeException();

	connA.commit();
	connB.commit();
} catch (Exception e) {
	e.printStackTrace();
	statementA.close();
	statementB.close();
	connA.rollback();
	connB.rollback();
}finally{
	connA.close();
	connB.close();
}

我们这样做:把所有的Connection的自动提交都设置为false,一旦执行过程中发生异常,调用每个Connection的回滚方法,如果没异常,则全部提交。这样做也可以实现分布式事务操作。

jotm也是同样的思路,在上述工程中,使用jdbcTemplate操作,就会把使用的Connection的自动提交设置为false,同时把这个Connection交给事务管理,一旦抛出异常,事务就会把它拥有的所有Connection全部回滚。

#3 通过JNDI方式使用jotm

工程代码地址:通过JNDI方式使用jotm

再介绍下通过JNDI方式如何来使用jotm,以及碰到的最新版jotm-core中的一个bug。

##3.1 操作代码

public void save(User user){
	UserTransaction userTransaction=null;
	try {
		Context ctx = new InitialContext();
		DataSource dataSourceA = (DataSource) ctx.lookup("java:comp/env/jdbc/dataSourceA");  
	    DataSource dataSourceB = (DataSource) ctx.lookup("java:comp/env/jdbc/dataSourceB");  
	    userTransaction = (UserTransaction) ctx.lookup("java:comp/UserTransaction"); 
	    userTransaction.begin();
	    
	    Connection connA=dataSourceA.getConnection();
		Connection connB=dataSourceB.getConnection();
		
		Statement statementA=connA.createStatement();
		Statement statementB=connB.createStatement();
		
		String sqlA="insert into user(name,age) values('"+user.getName()+"',"+user.getAge()+")";
		String sqlB="insert into log(name,age) values('"+user.getName()+"',"+user.getAge()+")";
		
		statementA.execute(sqlA);
		statementB.execute(sqlB);
		
		userTransaction.commit();
	} catch (Exception e) {
		e.printStackTrace();
		if(userTransaction!=null){
			try {
				userTransaction.rollback();
			} catch (IllegalStateException | SecurityException
					| SystemException e1) {
				e1.printStackTrace();
			}
		}
	}
}
  • 第一步:先通过JNDI方式获取面向开发人员的UserTransaction事务
  • 第二步:通过JNDI方式获取dataSource,然后进行sql操作
  • 第三步:使用UserTransaction提交事务
  • 第四步:一旦执行过程中发生异常,使用UserTransaction回滚事务

##3.2 tomcat的JNDI配置

在tomcat的context.xml配置文件中如下方式配置:

###3.2.1 配置UserTransaction

配置如下:

<Transaction factory="org.objectweb.jotm.UserTransactionFactory"/>

这个配置默认将"java:comp/UserTransaction"和上述UserTransactionFactory产生的对象关联了起来(还不太了解JNDI的话,需要去补充下知识)。所以可以通过如下方式来获取:

userTransaction = (UserTransaction) ctx.lookup("java:comp/UserTransaction")

我们来看下,jotm提供的UserTransaction实现是什么对象,即该UserTransactionFactory产生的对象是?

jotm提供的UserTransaction实现

可以看到提供的UserTransaction实现是org.objectweb.jotm.Current。

###3.2.2 配置两个dataSource

配置如下:

	<Resource name="jdbc/dataSourceA"  
        auth="Container"  
        type="javax.sql.DataSource"  
        factory="org.objectweb.jotm.datasource.DataSourceFactory"  
        username="root"  
        password="ligang"  
        driverClassName="com.mysql.jdbc.Driver"  
        url="jdbc:mysql://localhost:3306/test?useUnicode=true&amp;characterEncoding=utf-8"/> 
        
 	<Resource name="jdbc/dataSourceB"  
        auth="Container"  
        type="javax.sql.DataSource"  
        factory="org.objectweb.jotm.datasource.DataSourceFactory"  
        username="root"  
        password="ligang"  
        driverClassName="com.mysql.jdbc.Driver"  
        url="jdbc:mysql://localhost:3306/test2?useUnicode=true&amp;characterEncoding=utf-8"/>

我们来仔细研究下,它到底用的是什么dataSource,来看下上述配置的factory即org.objectweb.jotm.datasource.DataSourceFactory的内容:

DataSourceFactory的内容1

可以看到这里和spring中的配置文件里基本差不多,多和上面的spring配置文件对比对比。

  • 创建StandardXADataSource,设置相关参数
  • 创建StandardXAPoolDataSource,设置相关参数

继续,下面还有:

DataSourceFactory的内容2

将StandardXADataSource设置进StandardXAPoolDataSource中。 同时StandardXAPoolDataSource需要设置下事务管理器TransactionManager,通过jotm对象来获取的。

###3.2.3 最新版本的一个bug

上述事务管理器是从jotm对象获取的,我们继续看下jotm是如何来的?这里正是jotm-core-2.3.1-M1.jar出现bug的地方:

输入图片说明

即在加载DataSourceFactory类的时候,就会创建Jotm,来详细看下2.3.1-M1版本的创建方法:

public Jotm(boolean local, boolean bound) throws NamingException {
    this(local, bound, null);
}

可以看到,这里的第三个参数为null,继续看下第三个参数是干什么的?

jotm的创建

我们可以看到第三个参数为null,会产生运行时异常即空指针异常,没有捕获到继续向上层传递,而DataSourceFactory也没有捕获到,直接导致DataSourceFactory类加载失败。

解决办法就是换成低版本的jotm-core,如2.2.2版本就可以了,不会产生上述问题。或者直接调用三个参数的构造函数,对于第三个参数给出一个空的实现

#4 结束语

本篇主要说明了与spring集成方式的jotm案例、使用jndi方式的jotm案例。下一篇就该详细介绍下整个过程的执行原理。提出的问题如下:

  • jotm做了哪方面的工作?
  • xapool做了哪方面的工作?
  • 2pc的过程怎么体现的?
展开阅读全文
加载中

作者的其它热门文章

打赏
2
19 收藏
分享
打赏
5 评论
19 收藏
2
分享
返回顶部
顶部