[转]Spring+iBatis+JOTM实现JTA事务

Spring+iBatis+JOTM实现JTA事务

 

JOTM是个开源的JTA事务管理组件，可以让程序脱离J2EE容器而获得分布式事务管理的能力。

 

测试过程如下：

 

一、环境

 

1、准备软件环境

 spring-framework-2.5.6.SEC01-with-dependencies.zip
 ibatis-2.3.4
 ow2-jotm-dist-2.1.4-bin.tar.gz
 MySQL-5.1
 JDK1.5

 

2、创建数据库环境，注意数据库引擎为InnoDB，只有这样才能支持事务。

 

CREATE DATABASE IF NOT EXISTS testdb_a    DEFAULT CHARACTER SET utf8; 

USE testdb_a; 

DROP TABLE IF EXISTS tab_a; 

CREATE TABLE tab_a ( 
    id bigint(20) NOT NULL, 
    name varchar(60) DEFAULT NULL, 
    address varchar(120) DEFAULT NULL, 
    PRIMARY KEY (id) 
) ENGINE=InnoDB DEFAULT CHARSET=utf8; 


CREATE DATABASE IF NOT EXISTS testdb_b    DEFAULT CHARACTER SET utf8; 

USE testdb_b; 

DROP TABLE IF EXISTS tab_b; 

CREATE TABLE tab_b ( 
    id bigint(20) NOT NULL, 
    name varchar(60) DEFAULT NULL, 
    address varchar(120) DEFAULT NULL, 
    PRIMARY KEY (id) 
) ENGINE=InnoDB DEFAULT CHARSET=utf8; 

二、建立项目testJOTM

 

1、建立项目后，准备依赖的类库，结构如下：

│    spring-aop.jar 
│    spring-beans.jar 
│    spring-context-support.jar 
│    spring-context.jar 
│    spring-core.jar 
│    spring-jdbc.jar 
│    spring-jms.jar 
│    spring-orm.jar 
│    spring-test.jar 
│    spring-tx.jar 
│    spring-web.jar 
│    spring-webmvc-portlet.jar 
│    spring-webmvc-struts.jar 
│    spring-webmvc.jar 
│    aspectjrt.jar 
│    aspectjweaver.jar 
│    cglib-nodep-2.1_3.jar 
│    asm-2.2.3.jar 
│    log4j-1.2.15.jar 
│    asm-commons-2.2.3.jar 
│    asm-util-2.2.3.jar 
│    aopalliance.jar 
│    mysql-connector-java-5.1.6-bin.jar 
│ 
├─ibatis 
│            ibatis-2.3.4.726.jar 
│            sql-map-2.dtd 
│            sql-map-config-2.dtd 
│ 
├─jotm 
│            license.txt 
│            xapool.jar 
│            jotm-core.jar 
│            jotm-standalone.jar 
│            jotm-jms.jar 
│            jotm-datasource.jar 
│            ow2-jta-1.1-spec.jar 
│            jotm-client.jar 
│ 
├─jakarta-commons 
│            commons-attributes-api.jar 
│            commons-attributes-compiler.jar 
│            commons-beanutils.jar 
│            commons-codec.jar 
│            commons-collections.jar 
│            commons-dbcp.jar 
│            commons-digester.jar 
│            commons-discovery.jar 
│            commons-fileupload.jar 
│            commons-httpclient.jar 
│            commons-io.jar 
│            commons-lang.jar 
│            commons-logging.jar 
│            commons-pool.jar 
│            commons-validator.jar 
│ 
├─junit 
│            junit-3.8.2.jar 
│            junit-4.4.jar 
│            license.txt 
│ 
└─log4j 
                log4j-1.2.15.jar

 

2、根据表建立entity和SQLMap

public class TabA implements Serializable { 
        private Long id; 
        private String name; 
        private String address; 
        //省略getter/setter

 

public class TabB implements Serializable { 
        private Long id; 
        private String name; 
        private String address; 
        //省略getter/setter

TabA.xml

<?xml version="1.0" encoding="UTF-8" ?> 
<!DOCTYPE sqlMap PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN" "http://ibatis.apache.org/dtd/sql-map-2.dtd" > 

<!-- 表名:tab_a --> 
<sqlMap namespace="tab_a"> 
        <typeAlias alias="TabA" type="com.lavasoft.stu.jtom.entity.TabA"/> 
        <resultMap id="result_base" class="TabA"> 
                <result property="id" column="id"/> 
                <result property="name" column="name"/> 
                <result property="address" column="address"/> 
        </resultMap> 
        <!-- 添加 --> 
        <insert id="insert" parameterClass="TabA"> 
                insert into tab_a( 
                id, 
                name, 
                address 
                ) values ( 
                #id#, 
                #name#, 
                #address# 
                ) 
                <selectKey keyProperty="id" resultClass="long"> 
                        select LAST_INSERT_ID() 
                </selectKey> 
        </insert> 
        <!-- 更新 --> 
        <update id="update" parameterClass="TabA"> 
                update tab_a set 
                id = #id#, 
                name = #name#, 
                address = #address# 
                where id = #id# 
        </update> 
        <!-- 删除 --> 
        <delete id="deleteById" parameterClass="long"> 
                delete from tab_a 
                where id = #value# 
        </delete> 
        <!-- 根据ID获取 --> 
        <select id="findById" parameterClass="long" resultMap="tab_a.result_base"> 
                select * 
                from tab_a 
                where id = #value# 
        </select> 
</sqlMap>

 

TabB.xml

<?xml version="1.0" encoding="UTF-8" ?> 
<!DOCTYPE sqlMap PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN" "http://ibatis.apache.org/dtd/sql-map-2.dtd" > 

<!-- 表名:tab_b --> 
<sqlMap namespace="tab_b"> 
        <typeAlias alias="TabB" type="com.lavasoft.stu.jtom.entity.TabB"/> 
        <resultMap id="result_base" class="TabB"> 
                <result property="id" column="id"/> 
                <result property="name" column="name"/> 
                <result property="address" column="address"/> 
        </resultMap> 
        <!-- 添加 --> 
        <insert id="insert" parameterClass="TabB"> 
                insert into tab_b( 
                id, 
                name, 
                address 
                ) values ( 
                #id#, 
                #name#, 
                #address# 
                ) 
                <selectKey keyProperty="id" resultClass="long"> 
                        select LAST_INSERT_ID() 
                </selectKey> 
        </insert> 
        <!-- 更新 --> 
        <update id="update" parameterClass="TabB"> 
                update tab_b set 
                id = #id#, 
                name = #name#, 
                address = #address# 
                where id = #id# 
        </update> 
        <!-- 删除 --> 
        <delete id="deleteById" parameterClass="long"> 
                delete from tab_b 
                where id = #value# 
        </delete> 
        <!-- 根据ID获取 --> 
        <select id="findById" parameterClass="long" resultMap="tab_b.result_base"> 
                select * 
                from tab_b 
                where id = #value# 
        </select> 
</sqlMap>

 

/** 
* TabADAO 
* 
* @author leizhimin 2009-6-25 12:39:19 
*/ 
public interface TabADAO { 

        /** 
         * 保存一个TabA对象 
         * 
         * @param tabA TabA对象 
         * @return 返回保存后的对象 
         */ 
        TabA saveTabA(TabA tabA); 

        /** 
         * 更新一个TabA 
         * 
         * @param tabA TabA对象 
         * @return 返回更新后的对象 
         */ 
        TabA updateTabA(TabA tabA); 

        /** 
         * 删除指定标识的一个TabA 
         * 
         * @param id TabA标识 
         */ 
        void deleteTabAById(Long id); 

        /** 
         * 获取指定标识的TabA 
         * 
         * @param id TabA标识 
         * @return 所查询到的TabA 
         */ 
        TabA findTabAById(Long id); 
}

 

/** 
* TabADAO 
* 
* @author leizhimin 2009-6-25 12:43:55 
*/ 
public class TabADAOImpl extends SqlMapClientDaoSupport implements TabADAO { 

        /** 
         * 保存一个TabA对象 
         * 
         * @param tabA TabA对象 
         * @return 返回保存后的对象 
         */ 
        public TabA saveTabA(TabA tabA) { 
                Long id = (Long) getSqlMapClientTemplate().insert("tab_a.insert", tabA); 
                tabA.setId(id); 
                return tabA; 
        } 

        /** 
         * 更新一个TabA 
         * 
         * @param tabA TabA对象 
         * @return 返回更新后的对象 
         */ 
        public TabA updateTabA(TabA tabA) { 
                getSqlMapClientTemplate().update("tab_a.update", tabA); 
                return tabA; 
        } 

        /** 
         * 删除指定标识的一个TabA 
         * 
         * @param id TabA标识 
         */ 
        public void deleteTabAById(Long id) { 
                getSqlMapClientTemplate().delete("tab_a.deleteById",id); 
        } 

        /** 
         * 获取指定标识的TabA 
         * 
         * @param id TabA标识 
         * @return 所查询到的TabA 
         */ 
        public TabA findTabAById(Long id) { 
                return (TabA) getSqlMapClientTemplate().queryForObject("tab_a.findById",id); 
        } 
}

 

B的DAO和A类似，就不写了。

 

/** 
* 测试JOTM的Service 
* 
* @author leizhimin 2009-6-25 12:53:55 
*/ 
public interface StuJotmService { 
        /** 
         * 同时保存TabA、TabB 
         * 
         * @param a TabA对象 
         * @param b TabB对象 
         */ 
        void saveAB(TabA a, TabB b); 

        /** 
         * 同时更新TabA、TabB 
         * 
         * @param a TabA对象 
         * @param b TabB对象 
         */ 
        void updateAB(TabA a, TabB b); 

        /** 
         * 删除指定id的TabA、TabB记录 
         * 
         * @param id 指定id 
         */ 
        void deleteABif(Long id); 
}

 

/** 
* Created by IntelliJ IDEA. 
* 
* @author leizhimin 2009-6-25 12:58:48 
*/ 
//@Transactional 
public class StuJotmServiceImpl implements StuJotmService { 
        private TabADAO tabADAO; 
        private TabBDAO tabBDAO; 

        /** 
         * 同时保存TabA、TabB 
         * 
         * @param a TabA对象 
         * @param b TabB对象 
         */ 
//        @Transactional(readOnly=false) 
        public void saveAB(TabA a, TabB b) { 
                tabADAO.saveTabA(a); 
                tabBDAO.saveTabB(b); 
        } 

        /** 
         * 同时更新TabA、TabB 
         * 
         * @param a TabA对象 
         * @param b TabB对象 
         */ 
//        @Transactional(readOnly=false) 
        public void updateAB(TabA a, TabB b) { 
                tabADAO.updateTabA(a); 
                tabBDAO.updateTabB(b); 
        } 

        /** 
         * 删除指定id的TabA、TabB记录 
         * 
         * @param id 指定id 
         */ 
//        @Transactional(readOnly=false) 
        public void deleteABif(Long id) { 
                tabADAO.deleteTabAById(id); 
                tabBDAO.deleteTabBById(id); 
        } 

        public void setTabADAO(TabADAO tabADAO) { 
                this.tabADAO = tabADAO; 
        } 

        public void setTabBDAO(TabBDAO tabBDAO) { 
                this.tabBDAO = tabBDAO; 
        } 
}

 

/** 
* Spring上下文工具 
* 
* @author leizhimin 2008-8-13 14:42:58 
*/ 

public class ApplicationContextUtil { 
        private static ApplicationContext applicationContext; 

        static { 
                if (applicationContext == null) 
                        applicationContext = rebuildApplicationContext(); 
        } 

        /** 
         * 重新构建Spring应用上下文环境 
         * 
         * @return ApplicationContext 
         */ 
        public static ApplicationContext rebuildApplicationContext() { 
                return new ClassPathXmlApplicationContext("/ApplicationContext.xml"); 
        } 

        /** 
         * 获取Spring应用上下文环境 
         * 
         * @return 
         */ 
        public static ApplicationContext getApplicationContext() { 
                return applicationContext; 
        } 

        /** 
         * 简单的上下文环境测试 
         */ 
        public static void main(String[] args) { 
                rebuildApplicationContext(); 
                if (applicationContext == null) { 
                        System.out.println("ApplicationContext is null"); 
                } else { 
                        System.out.println("ApplicationContext is not null!"); 
                } 
        } 
}

 

三、做JTOM、Spring、iBatis、Log4j等配置

 

JOTM配置：carol.properties

#JNDI调用协议 
carol.protocols=jrmp 
#不使用CAROL JNDI封装器        
carol.start.jndi=false 
#不启动命名服务器 
carol.start.ns=false 

 

Spring配置：ApplicationContext.xml

<?xml version="1.0" encoding="UTF-8"?> 
<!-- 局部单元测试使用，不正式发布，不要删除 --> 
<beans xmlns="http://www.springframework.org/schema/beans" 
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
             xmlns:jee="http://www.springframework.org/schema/jee" 
             xmlns:aop="http://www.springframework.org/schema/aop" 
             xmlns:tx="http://www.springframework.org/schema/tx" 
             xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd 
                     http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.0.xsd 
                     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd 
                     http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd"> 

        <!--指定Spring配置中用到的属性文件--> 
        <bean id="propertyConfig" 
                    class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> 
                <property name="locations"> 
                        <list> 
                                <value>classpath:jdbc.properties</value> 
                        </list> 
                </property> 
        </bean> 
        <!-- JOTM实例 --> 
        <bean id="jotm" class="org.springframework.transaction.jta.JotmFactoryBean"/> 
        <!-- JTA事务管理器 --> 
        <bean id="myJtaManager" 
                    class="org.springframework.transaction.jta.JtaTransactionManager"> 
                <property name="userTransaction"> 
                        <ref local="jotm"/> 
                </property> 
        </bean> 
        <!-- 数据源A --> 
        <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="${jdbc.driver}"/> 
                                <property name="url" value="${jdbc.url}"/> 
                        </bean> 
                </property> 
                <property name="user" value="${jdbc.username}"/> 
                <property name="password" value="${jdbc.password}"/> 
        </bean> 
        <!-- 数据源B --> 
        <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="${jdbc2.driver}"/> 
                                <property name="url" value="${jdbc2.url}"/> 
                        </bean> 
                </property> 
                <property name="user" value="${jdbc2.username}"/> 
                <property name="password" value="${jdbc.password}"/> 
        </bean> 
        <!-- 事务切面配置 --> 
        <aop:config> 
                <aop:pointcut id="serviceOperation" 
                                            expression="execution(* *..servi1ce*..*(..))"/> 
                <aop:advisor pointcut-ref="serviceOperation" 
                                         advice-ref="txAdvice"/> 
        </aop:config> 
        <!-- 通知配置 --> 
        <tx:advice id="txAdvice" transaction-manager="myJtaManager"> 
                <tx:attributes> 
                        <tx:method name="delete*" rollback-for="Exception"/> 
                        <tx:method name="save*" rollback-for="Exception"/> 
                        <tx:method name="update*" rollback-for="Exception"/> 
                        <tx:method name="*" read-only="true" rollback-for="Exception"/> 
                </tx:attributes> 
        </tx:advice> 

        <!--根据dataSourceA和sql-map-config_A.xml创建一个SqlMapClientA--> 
        <bean id="sqlMapClientA" 
                    class="org.springframework.orm.ibatis.SqlMapClientFactoryBean"> 
                <property name="dataSource"> 
                        <ref local="dataSourceA"/> 
                </property> 
                <property name="configLocation"> 
                        <value>sql-map-config_A.xml</value> 
                </property> 
        </bean> 
        <!--根据dataSourceB和sql-map-config_B.xml创建一个SqlMapClientB--> 
        <bean id="sqlMapClientB" 
                    class="org.springframework.orm.ibatis.SqlMapClientFactoryBean"> 
                <property name="dataSource"> 
                        <ref local="dataSourceB"/> 
                </property> 
                <property name="configLocation"> 
                        <value>sql-map-config_B.xml</value> 
                </property> 
        </bean> 
        <!--根据sqlMapClientA创建一个SqlMapClientTemplate的模版类实例sqlMapClientTemplateA--> 
        <bean id="sqlMapClientTemplateA" 
                    class="org.springframework.orm.ibatis.SqlMapClientTemplate"> 
                <property name="sqlMapClient" ref="sqlMapClientA"/> 
        </bean> 
        <!--根据sqlMapClientB创建一个SqlMapClientTemplate的模版类实例sqlMapClientTemplateB--> 
        <bean id="sqlMapClientTemplateB" 
                    class="org.springframework.orm.ibatis.SqlMapClientTemplate"> 
                <property name="sqlMapClient" ref="sqlMapClientB"/> 
        </bean> 

        <!-- 配置DAO，并注入所使用的sqlMapClientTemplate实例 --> 
        <bean id="tabADAO" class="com.lavasoft.stu.jtom.dao.impl.TabADAOImpl"> 
                <property name="sqlMapClientTemplate" ref="sqlMapClientTemplateA"/> 
        </bean> 
        <bean id="tabBDAO" class="com.lavasoft.stu.jtom.dao.impl.TabBDAOImpl"> 
                <property name="sqlMapClientTemplate" ref="sqlMapClientTemplateB"/> 
        </bean> 

        <!-- Service配置，注入DAO --> 
        <bean id="stuJotmService" class="com.lavasoft.stu.jtom.service.StuJotmServiceImpl"> 
                <property name="tabADAO" ref="tabADAO"/> 
                <property name="tabBDAO" ref="tabBDAO"/> 
        </bean> 
</beans>

 

数据库配置：jdbc.properties

jdbc.database=cms_release 
jdbc.driver=com.mysql.jdbc.Driver 
jdbc.url=jdbc:mysql://192.168.0.2:3306/testdb_a?useUnicode=true&characterEncoding=utf8&autoReconnect=true&zeroDateTimeBehavior=convertToNull 
jdbc.username=root 
jdbc.password=leizhimin 

jdbc2.database=cms_release 
jdbc2.driver=com.mysql.jdbc.Driver 
jdbc2.url=jdbc:mysql://192.168.0.1:3306/testdb_b?useUnicode=true&characterEncoding=utf8&autoReconnect=true&zeroDateTimeBehavior=convertToNull 
jdbc2.username=root 
jdbc2.password=leizhimin 

 

iBatis的SQLMap配置：

sql-map-config_A.xml

<?xml version="1.0" encoding="UTF-8"?> 
<!DOCTYPE sqlMapConfig 
                PUBLIC "-//ibatis.apache.org//DTD SQL Map Config 2.0//EN" 
                "http://ibatis.apache.org/dtd/sql-map-config-2.dtd"> 

<sqlMapConfig> 
        <settings cacheModelsEnabled="true" enhancementEnabled="true" 
                            lazyLoadingEnabled="true" errorTracingEnabled="true" 
                            useStatementNamespaces="true"/> 

        <sqlMap resource="com/lavasoft/stu/jtom/entity/sqlmap/TabA.xml"/> 

</sqlMapConfig>

 

sql-map-config_B.xml

<?xml version="1.0" encoding="UTF-8"?> 
<!DOCTYPE sqlMapConfig 
                PUBLIC "-//ibatis.apache.org//DTD SQL Map Config 2.0//EN" 
                "http://ibatis.apache.org/dtd/sql-map-config-2.dtd"> 

<sqlMapConfig> 
        <settings cacheModelsEnabled="true" enhancementEnabled="true" 
                            lazyLoadingEnabled="true" errorTracingEnabled="true" 
                            useStatementNamespaces="true"/> 

        <sqlMap resource="com/lavasoft/stu/jtom/entity/sqlmap/TabB.xml"/> 

</sqlMapConfig>

 

日志的配置：log4j.properties

log4j.rootLogger=INFO,CONSOLE,LOGFILE 

log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender 
log4j.appender.Threshold=INFO 
log4j.appender.CONSOLE.Target=System.out 
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout 
log4j.appender.CONSOLE.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss } - %-5p %c        %x - %m%n 

log4j.appender.LOGFILE=org.apache.log4j.RollingFileAppender 
log4j.appender.LOGFILE.File=contestlog.log 
log4j.appender.LOGFILE.MaxFileSize=500KB 
log4j.appender.LOGFILE.MaxBackupIndex=10 
log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout 
log4j.appender.LOGFILE.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss } -    %-p %c     %x - %m%n 

log4j.logger.com.ibatis=INFO 
log4j.logger.com.ibatis.common.jdbc.SimpleDataSource=INFO 
log4j.logger.com.ibatis.common.jdbc.ScriptRunner=INFO 
log4j.logger.com.ibatis.sqlmap.engine.impl.SqlMapClientDelegate=INFO 
log4j.logger.java.sql.Connection=debug 
log4j.logger.java.sql.Statement=INFO,CONSOLE 
log4j.logger.java.sql.PreparedStatement=INFO,CONSOLE 

 

四、测试

 

public class Test { 
        private static ApplicationContext ctx = ApplicationContextUtil.getApplicationContext(); 
        private static StuJotmService ser = (StuJotmService) ctx.getBean("stuJotmService"); 

        public static void test_() { 
                TabA a = new TabA(); 
                a.setId(1L); 
                a.setName("aaa"); 
                a.setAddress("address a"); 
                TabB b = new TabB(); 
                b.setId(1L); 
                b.setName("bbb"); 
                b.setAddress("address b"); 
                ser.saveAB(a, b); 
        } 

        public static void main(String[] args) { 
                test_(); 
        } 
}

 

然后将主键其中一个改掉进行测试，让另外一个主键重复，发现a、b数据库均不能成功写入，经过多次测试，验证jtom真正实现了分布式事务的管理。

附：org.springframework.transaction.jta.JotmFactoryBean在spring2.5.6中可以拷贝直接用