1. 技术文章
  2. 分布式事务系列（3.1）jotm的分布式案例

分布式事务系列（3.1）jotm的分布式案例

由 拥有回忆 提交于 2019-11-27 07:13:22

#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的过程怎么体现的？
标签
jotm
xapool
分布式事务
易学教程内所有资源均来自网络或用户发布的内容，如有违反法律规定的内容欢迎反馈！
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!