【分布式事务系列五】jotm的分布式案例

原创
2015/12/14 11:19
阅读数 610

#0 系列目录#

#1 与Spring集成方式使用jotm# 工程代码地址:与Spring集成方式使用jotm,先来感受下一个分布式事务的案例(使用一般的数据库驱动,不需要支持分布式XA协议):

##1.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
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();
    }
}

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

###1.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年;

###1.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加了进去。

###1.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则是必须的

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

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

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

  1. 第二步:使用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,同时将该连接纳入当前事务中。

  1. 第三步

一旦抛出异常,则需要进行事务的回滚操作。回滚就是将当前事务进行回滚,该事务的回滚会调用和它关联的所有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全部回滚

#2 通过JNDI方式使用jotm# 工程代码地址:通过JNDI方式使用jotm,再介绍下通过JNDI方式如何来使用jotm,以及碰到的最新版jotm-core中的一个bug。

##2.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回滚事务

##2.2 tomcat的JNDI配置## 在tomcat的context.xml配置文件中如下方式配置: ###2.2.1 配置UserTransaction### 配置如下:

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

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

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

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

输入图片说明

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

###2.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的内容:

输入图片说明

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

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

继续,下面还有:

输入图片说明

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

###2.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,继续看下第三个参数是干什么的?

输入图片说明

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

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

展开阅读全文
打赏
0
11 收藏
分享
加载中
要加上:
<bean id="jdbcTemplateA" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSourceA" />
</bean>

<bean id="jdbcTemplateB" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSourceB" />
</bean>
2017/02/08 12:47
回复
举报
1.2.1 dataSource和JdbcTemplate配置 是不是写得有问题, 没有发现配置 JdbcTemplate 呀
2017/02/08 12:33
回复
举报
更多评论
打赏
2 评论
11 收藏
0
分享
返回顶部
顶部