分布式事务JTA之实践:Spring+ATOMIKOS参考 博客分类： springjta spring

分布式事务JTA之实践:Spring+ATOMIKOS

作者: Michael 日期: 2012 年 2 月 28 日 发表评论 (4) 查看评论

本文的目录结构如下：

• 一、概述
• 二、应用场景
• 三、实验模拟需求
• 四、实例测试环境
• 五、源代码下载及配置介绍
• 六、测试验证

一、概述：

本文主要讲述如何基于Atomikos 和spring在项目中实现分布式事务管理

二、应用场景：

如果项目中的数据源来自多个数据库，同时又需要在多数据源中保证事务，此时就需要用到分布式事务处理了。

三、实验模拟需求：

比如有两个对象：用户信息、用户存款，用户信息存在数据库A、存款信息存在数据库B，若客户甲向乙转账，需要在数据库B中对甲、乙的存款信息修改，同时在数据库A中把甲、乙的备注信息最新为最近一次的操作时间。

四、实例测试环境：

• spring、hibernate3.2
• mysql5.1.51（需要版本5.0+）
• AtomikosTransactionsEssentials-3.7.0 （详细可参加它的官网：http://www.atomikos.com  ）

说明：

1. 测试的数据库需要支持分布式事务，同时JDBC要支持XA连接驱动。本次测试用的mysql5.1是支持事务的，JDBC驱动版本：mysql-connector-java-5.1.7-bin.jar，包含对 XA连接的支持：com.mysql.jdbc.jdbc2.optional.MysqlXAConnection。

2. 附件提供AtomikosTransactionsEssentials 3.7.0 lib包下载：AtomikosTransactionsEssentials-3.7.0-lib.zip。官方下载地址：http://www.atomikos.com/Main/TransactionsEssentialsDownloadForm，需要先注册才能下载。同时这里也提供目前3.7.0的下载链接：http://www.atomikos.com/downloads/transactions-essentials/com/atomikos/AtomikosTransactionsEssentials/3.7.0/AtomikosTransactionsEssentials-3.7.0-bin.zip

五、代码及配置介绍：

源代码下载：分布式事务实例演示源代码michael_jta_code.zip

1.代码的目录结构图如下：

转账测试的的代码片段：

1

/**

2

* 转账测试

3	* @param srcId

4	* @param destId

5	* @param money

6	* @return boolean

7

*/

8	public boolean doTestTransfer(String srcId, String destId, float money) {

9

10	BankAccount srcAccount = bankAccountDao.getByUserName(srcId);

11	BankAccount destAccount = bankAccountDao.getByUserName(destId);

12	if (srcAccount.getDeposit() < money) {

13	System.out.println("warn :" + srcAccount.getUserName()

14	+ " has not enough money to transfer");

15	return false;

16

}

17	srcAccount.setDeposit(srcAccount.getDeposit() - money);

18	destAccount.setDeposit(destAccount.getDeposit() + money);

19	// 把更新存款信息置于异常发生之前

20	bankAccountDao.update(srcAccount);

21	bankAccountDao.update(destAccount);

22

23	Date curTime = new Date();

24	UserInfo srcUser = userInfoDao.getById(srcId);

25	UserInfo destUser = userInfoDao.getById(destId);

26

27	destUser.setRemark1(curTime + "");

28	destUser.setRemark2(curTime + "");

29	// 把更新基本信息置于异常发生之前

30	userInfoDao.update(destUser);

31	srcUser.setRemark1(curTime + "");

32	if (srcAccount.getDeposit() < 18000) {

33	throw new RuntimeException("michael test exception for JTA  ");

34

}

35	srcUser.setRemark2(curTime + "");

36

37	userInfoDao.update(srcUser);

38	System.out.println("success done:" + srcAccount.getUserName()

39	+ " transfer ￥" + money + " to " + destAccount.getUserName());

40

41	return true;

42

}

2. 配置文件详细介绍：

jta.jdbc.properties

1	#see http://www.micmiu.com

2	# eg. for mysql

3	jdbc.SDS.class=com.mysql.jdbc.jdbc2.optional.MysqlXADataSource

4	jdbc.SDS.properties=URL=jdbc:mysql://192.168.8.253:3306/demota;user=root;password=111111

5

6	jdbc.SDS2.class=com.mysql.jdbc.jdbc2.optional.MysqlXADataSource

7	jdbc.SDS2.properties=URL=jdbc:mysql://192.168.8.150:3306/demota;user=root;password=111111

jta.properties

1	#see http://www.micmiu.com

2	com.atomikos.icatch.service=com.atomikos.icatch.standalone.UserTransactionServiceFactory

3	com.atomikos.icatch.console_file_name = tm.out

4	com.atomikos.icatch.log_base_name = tmlog

5	com.atomikos.icatch.tm_unique_name = com.atomikos.spring.jdbc.tm

6	com.atomikos.icatch.console_log_level = INFO

jta1.hibernate.cfg.xml

1	<!DOCTYPE hibernate-configuration

2	PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN"

3	"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

4

5	<hibernate-configuration>

6	<session-factory>

7	<property name="dialect">

8	org.hibernate.dialect.MySQL5Dialect

9	</property>

10	<property name="hbm2ddl.auto">update</property>

11	<mapping class="michael.jta.atomikos.domain.UserInfo" />

12	</session-factory>

13

14	</hibernate-configuration>

jta2.hibernate.cfg.xml

1	<!DOCTYPE hibernate-configuration

2	PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN"

3	"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

4

5	<hibernate-configuration>

6

7	<session-factory>

8	<property name="show_sql">true</property>

9	<property name="dialect">

10	org.hibernate.dialect.MySQL5Dialect

11	</property>

12	<property name="hbm2ddl.auto">update</property>

13	<mapping class="michael.jta.atomikos.domain.BankAccount" />

14	</session-factory>

15

16	</hibernate-configuration>

jta.spring.xml

 

1	<?xml version="1.0" encoding="UTF-8"?>

2	<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

3

<beans>

4	<!-- Configurer that replaces ${...} placeholders with values from properties files -->

5	<bean id="propertyConfigurer"

6	class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">

7	<property name="locations">

8

<list>

9	<value>classpath:jta.jdbc.properties</value>

10

</list>

11	</property>

12

</bean>

13

14	<!-- 数据源配置 http://sjsky.iteye.com-->

15	<bean id="SDS" class="com.atomikos.jdbc.SimpleDataSourceBean"

16	init-method="init" destroy-method="close">

17	<property name="uniqueResourceName">

18	<value>SDS</value>

19	</property>

20	<property name="xaDataSourceClassName">

21	<value>${jdbc.SDS.class}</value>

22	</property>

23	<property name="xaDataSourceProperties">

24	<value>${jdbc.SDS.properties}</value>

25	</property>

26	<property name="exclusiveConnectionMode">

27	<value>true</value>

28	</property>

29	<property name="connectionPoolSize">

30	<value>3</value>

31	</property>

32	<property name="validatingQuery">

33	<value>SELECT 1</value>

34	</property>

35

</bean>

36

37	<bean id="SDS2" class="com.atomikos.jdbc.SimpleDataSourceBean"

38	init-method="init" destroy-method="close">

39	<property name="uniqueResourceName">

40	<value>SDS2</value>

41	</property>

42	<property name="xaDataSourceClassName">

43	<value>${jdbc.SDS2.class}</value>

44	</property>

45	<property name="xaDataSourceProperties">

46	<value>${jdbc.SDS2.properties}</value>

47	</property>

48	<property name="exclusiveConnectionMode">

49	<value>true</value>

50	</property>

51	<property name="connectionPoolSize">

52	<value>3</value>

53	</property>

54	<property name="validatingQuery">

55	<value>SELECT 1</value>

56	</property>

57

</bean>

58

59	<!-- sessionFactory http://www.micmiu.com-->

60	<bean id="sessionFactory1"

61	class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">

62	<property name="dataSource" ref="SDS" />

63	<property name="configLocation"

64	value="classpath:jta1.hibernate.cfg.xml" />

65

</bean>

66

67	<bean id="sessionFactory2"

68	class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">

69	<property name="dataSource" ref="SDS2" />

70	<property name="configLocation"

71	value="classpath:jta2.hibernate.cfg.xml" />

72

</bean>

73

74	<!-- TransactionManager http://www.micmiu.com-->

75	<!-- Construct Atomikos UserTransactionManager, needed to configure Spring -->

76	<bean id="atomikosTransactionManager"

77	class="com.atomikos.icatch.jta.UserTransactionManager"

78	init-method="init" destroy-method="close">

79	<!--  when close is called, should we force transactions to terminate or not? -->

80	<property name="forceShutdown">

81	<value>true</value>

82	</property>

83

</bean>

84

85	<!-- Also use Atomikos UserTransactionImp, needed to configure Spring  -->

86	<bean id="atomikosUserTransaction"

87	class="com.atomikos.icatch.jta.UserTransactionImp">

88	<property name="transactionTimeout">

89	<value>300</value>

90	</property>

91

</bean>

92

93	<!-- Configure the Spring framework to use JTA transactions from Atomikos -->

94	<bean id="springJTATransactionManager"

95	class="org.springframework.transaction.jta.JtaTransactionManager">

96

97	<property name="transactionManager">

98	<ref bean="atomikosTransactionManager" />

99	</property>

100	<property name="userTransaction">

101	<ref bean="atomikosUserTransaction" />

102	</property>

103

</bean>

104

105	<!-- Configure DAO http://www.micmiu.com-->

106	<bean id="userInfoDao"

107	class="michael.jta.atomikos.dao.impl.UserInfoDaoImpl">

108	<property name="sessionFactory" ref="sessionFactory1" />

109

</bean>

110	<bean id="bankAccountDao"

111	class="michael.jta.atomikos.dao.BankAccountDao">

112	<property name="sessionFactory" ref="sessionFactory2" />

113

</bean>

114

115	<bean id="bankAccountService"

116	class="michael.jta.atomikos.service.impl.BankAccountServiceImpl">

117	<property name="userInfoDao" ref="userInfoDao" />

118	<property name="bankAccountDao" ref="bankAccountDao" />

119

</bean>

120

121	<!-- 定义事务规则的拦截器 http://www.micmiu.com-->

122	<bean id="transactionInterceptor"

123	class="org.springframework.transaction.interceptor.TransactionInterceptor">

124	<property name="transactionManager"

125	ref="springJTATransactionManager" />

126	<property name="transactionAttributes">

127

<props>

128	<prop key="*">PROPAGATION_REQUIRED</prop>

129

</props>

130	</property>

131

</bean>

132

133	<!-- 声明式事务边界配置 所有的bean公用一个代理bean http://sjsky.iteye.com-->

134	<bean id="baseTransactionProxy"

135	class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"

136	abstract="true">

137	<property name="transactionManager"

138	ref="springJTATransactionManager" />

139	<property name="transactionAttributes">

140

<props>

141	<!-- 可以根据实际情况细化配置提高性能 -->

142	<prop key="*">PROPAGATION_REQUIRED</prop>

143

</props>

144	</property>

145

</bean>

146

147	<bean id="bankAccountServiceProxy" parent="baseTransactionProxy">

148	<property name="target">

149	<ref bean="bankAccountService" />

150	</property>

151

</bean>

152

153

</beans>

 

六、测试验证

1. 初始化数据：

因为mysql数据库表的类型有事务和非事务之分，建表时一定要注意确保表的类型是事务控制的：InnoDB

数据库A（192.168.8.253）：

1	DROP DATABASE IF EXISTS demota;

2	CREATE DATABASE demota;

3	USE demota;

4	DROP TABLE  IF EXISTS tb_user_info;

5

6	CREATE TABLE tb_user_info (

7	user_name varchar(20),

8	real_name varchar(10),

9	remark1 varchar(50),

10	remark2 varchar(50)

11	) ENGINE = InnoDB;

12

13	INSERT INTO tb_user_info (user_name,real_name,remark1,remark2) VALUES ('husband','husband','','');

14	INSERT INTO tb_user_info (user_name,real_name,remark1,remark2) VALUES ('wife','wife','','');

数据库B（192.168.8.150）：

1	DROP DATABASE IF EXISTS demota;

2	CREATE DATABASE demota;

3	USE demota;

4	DROP TABLE  IF EXISTS tb_account;

5	CREATE TABLE tb_account (

6	id int AUTO_INCREMENT,

7	user_name varchar(20),

8	deposit float(10,2),

9	PRIMARY KEY(id)

10	) ENGINE = InnoDB;

11

12	INSERT INTO tb_account (user_name,deposit) VALUES ('husband',20000.00);

13	INSERT INTO tb_account (user_name,deposit) VALUES ('wife',10000.00);

2. 测试过程：

ps: 代码中模拟了异常出现的条件：如果账户金额<18000会抛出异常

JtaRunMainTest.java

1	package michael.jta.atomikos;

2

3	import michael.jta.atomikos.service.BankAccountService;

4

5	import org.springframework.context.ApplicationContext;

6	import org.springframework.context.support.ClassPathXmlApplicationContext;

7

8

/**

9	* @author michael

10

*

11

*/

12	public class JtaRunMainTest {

13

14

/**

15	* @param args

16

*/

17	public static void main(String[] args) {

18	System.out.println("------------start");

19	ApplicationContext appCt = new ClassPathXmlApplicationContext(

20	"jta.spring.xml");

21	System.out.println("------------finished init xml");

22

23	Object bean = appCt.getBean("bankAccountServiceProxy");

24	System.out.println(bean.getClass());

25	BankAccountService service = (BankAccountService) bean;

26	service.doTestTransfer("husband", "wife", 2000);

27

}

28

}

运行第一次结果：

1	------------start

2	------------finished init xml

3	class $Proxy11

4	Hibernate: select bankaccoun0_.id as id2_, bankaccoun0_.deposit as deposit2_, bankaccoun0_.user_name as user3_2_ from tb_account bankaccoun0_ where bankaccoun0_.user_name=?

5	Hibernate: select bankaccoun0_.id as id2_, bankaccoun0_.deposit as deposit2_, bankaccoun0_.user_name as user3_2_ from tb_account bankaccoun0_ where bankaccoun0_.user_name=?

6	success done:husband transfer ￥2000.0 to wife

7	Hibernate: update tb_account set deposit=?, user_name=? where id=?

8	Hibernate: update tb_account set deposit=?, user_name=? where id=?

运行第二次结果：

1	------------start

2	------------finished init xml

3	class $Proxy11

4	Hibernate: select bankaccoun0_.id as id2_, bankaccoun0_.deposit as deposit2_, bankaccoun0_.user_name as user3_2_ from tb_account bankaccoun0_ where bankaccoun0_.user_name=?

5	Hibernate: select bankaccoun0_.id as id2_, bankaccoun0_.deposit as deposit2_, bankaccoun0_.user_name as user3_2_ from tb_account bankaccoun0_ where bankaccoun0_.user_name=?

6	Exception in thread "main" java.lang.RuntimeException: michael test exception for JTA

7	at michael.jta.atomikos.service.impl.BankAccountServiceImpl.doTestTransfer(BankAccountServiceImpl.java:51)

8	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)

9	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)

10	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)

11	at java.lang.reflect.Method.invoke(Method.java:597)

12	at org.springframework.aop.support.AopUtils.invokeJoinpointUsingReflection(AopUtils.java:299)

13	at org.springframework.aop.framework.ReflectiveMethodInvocation.invokeJoinpoint(ReflectiveMethodInvocation.java:172)

14	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:139)

15	at org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:107)

16	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:161)

17	at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:202)

18	at $Proxy11.doTestTransfer(Unknown Source)

19	at michael.jta.atomikos.JtaRunMainTest.main(JtaRunMainTest.java:26)

测试过程中数据库查询的结果截图：

从上面的数据库截图可见，第一正常运行时两个数据库同步更新了，第二次运行发生异常后，两个数据库的数据为发生变化，实现了事务回滚。

原创文章，转载请注明： 转载自micmiu – 大大的技术 | 小小的生活[ http://www.micmiu.com/ ]

本文链接地址: http://www.micmiu.com/j2ee/spring/jta-spring-atomikos/