超简单的Atomikos与Spring管理的分布式事务--深入JDBC解释分布式事务的实现

maven引入相应的Atomikos依赖类库，除此之外还需要mysql和oracle的jdbc驱动类

		<dependency>
			<groupId>com.atomikos</groupId>
			<artifactId>transactions-jdbc</artifactId>
			<version>4.0.6</version>
		</dependency>
		<dependency>
			<groupId>javax.transaction</groupId>
			<artifactId>jta</artifactId>
			<version>1.1</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.springframework/spring-tx -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-tx</artifactId>
			<version>${spring-version}</version>
		</dependency>
	....

增加spring配置文件（这里数据库用户密码留空)

<?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:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
         http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
         http://www.springframework.org/schema/context 
		 http://www.springframework.org/schema/context/spring-context-4.0.xsd
		 http://www.springframework.org/schema/tx
		 http://www.springframework.org/schema/tx/spring-tx-4.0.xsd">
	<bean id="springTransactionManager" class="org.springframework.transaction.jta.JtaTransactionManager">
		<property name="transactionManager">
			<ref bean="atomikosTransactionManager" />
		</property>
		<property name="userTransaction">
			<ref bean="atomikosUserTransaction" />
		</property>
		<property name="allowCustomIsolationLevels" value="true" />
	</bean>
	<bean id="atomikosTransactionManager" class="com.atomikos.icatch.jta.UserTransactionManager" init-method="init" destroy-method="close">
		<property name="forceShutdown">
			<value>true</value>
		</property>
	</bean>
	<bean id="atomikosUserTransaction" class="com.atomikos.icatch.jta.UserTransactionImp">
		<!-- 分布式事务超时的时间单位秒 -->
		<property name="transactionTimeout">
			<value>10</value>
		</property>
	</bean>
	<bean id="firstDb" class="com.atomikos.jdbc.AtomikosDataSourceBean" init-method="init" destroy-method="close">
		<description>Oracle数据源</description>
		<property name="uniqueResourceName">
			<value>oracle_sources_ds</value>
		</property>
		<property name="xaDataSourceClassName">
			<value>oracle.jdbc.xa.client.OracleXADataSource</value>
		</property>
		<property name="xaProperties">
			<props>
				<prop key="user">flow</prop>
				<prop key="password"></prop>
				<prop key="uRL">jdbc:oracle:thin:@//192.168.0.101/orcl</prop>
			</props>
		</property>
		<property name="testQuery">
			<value>select sysdate from dual</value>
		</property>
		<property name="poolSize" value="5" />
	</bean>
	<bean id="secondDb" class="com.atomikos.jdbc.AtomikosDataSourceBean" init-method="init" destroy-method="close">
		<property name="uniqueResourceName" value="mysql_sources_ds" />
		<property name="xaDataSourceClassName" value="com.mysql.jdbc.jdbc2.optional.MysqlXADataSource" />
		<property name="xaProperties">
			<props>
				<prop key="url">jdbc:mysql://localhost:3306/car
				</prop>
				<prop key="user">root</prop>
				<prop key="password"></prop>
				<prop key="pinGlobalTxToPhysicalConnection">true</prop>
			</props>
		</property>
		<property name="minPoolSize" value="5" />
		<property name="maxPoolSize" value="10" />
		<property name="borrowConnectionTimeout" value="30" />
		<property name="testQuery" value="select 1" />
	</bean>
</beans>

发起分布式事务示例代码,这样你可以测试以下两个update语句符合ACID的特性，测试的方法可以将第二条Oracle执行的update SQL字符加长，最终结果发现Mysql的update语句没有被提交

public class TestAtomikos {
	public static void main(String[] args) {
		ApplicationContext context = new ClassPathXmlApplicationContext("base_jta.xml");
		PlatformTransactionManager transactionManager = context.getBean(PlatformTransactionManager.class);
		DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
		TransactionStatus transaction = transactionManager.getTransaction(definition);
		DataSource orcl = context.getBean("firstDb", DataSource.class);
		DataSource mysql = context.getBean("secondDb", DataSource.class);
		try (Connection mysqlConn = mysql.getConnection(); Connection orclConn = orcl.getConnection();) {
			Statement mysqlStat = mysqlConn.createStatement();
			String usql = "UPDATE LOGIN_LOG w SET w.USERNAME ='Mysql Name' WHERE w.ID ='a1'";
			mysqlStat.executeUpdate(usql);
			Statement orclStat = orclConn.createStatement();
			String updateSql = "UPDATE LOGIN_LOG w SET w.USERNAME ='Oracle Name' WHERE w.ID ='a2'";
			orclStat.executeUpdate(updateSql);
			transactionManager.commit(transaction);
		} catch (Exception e) {
			e.printStackTrace();
			transactionManager.rollback(transaction);
		}
	}
}

截止上面所说通过第三方类库（Atomikos和Spring全局事务管理器）来实现分布式事务,那么通过JDBC是如何实现，请继续往下看：

首先把spring配置文件改成：

<?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:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
         http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
         http://www.springframework.org/schema/context 
		 http://www.springframework.org/schema/context/spring-context-4.0.xsd
		 http://www.springframework.org/schema/tx
		 http://www.springframework.org/schema/tx/spring-tx-4.0.xsd">
	<bean id="mysql_oracle_ds" class="com.mysql.jdbc.jdbc2.optional.MysqlXADataSource">
		<property name="user" value="root"/>
		<property name="password" value="123456"/>
		<property name="url" value="jdbc:mysql://localhost:3306/car"/>
		<property name="pinGlobalTxToPhysicalConnection" value="true"/>
	</bean>
	<bean id="oracle_sources_ds" class="oracle.jdbc.xa.client.OracleXADataSource">
		<property name="user" value="user"/>
		<property name="password" value="password"/>
		<property name="uRL" value="jdbc:oracle:thin:@//192.168.0.209/orcl"/>
	</bean>
</beans>

这里Spring配置的是XA数据源，在运行前先普及下XA协议

        X/Open XA 接口是双向的系统接口，在事务管理器（Transaction Manager）以及一个或多个
资源管理器（Resource Manager）之间形成通信桥梁。事务管理器控制着JTA 事务，管理事
务生命周期，并协调资源。在JTA 中，事务管理器抽象为javax.transaction.TransactionManager
接口，并通过底层事务服务（即JTS）实现。资源管理器负责控制和管理实际资源（如数据
库或JMS 队列）。下图说明了事务管理器、资源管理器，以及典型JTA 环境中客户端应用之
间的关系：

 而分布式事务中的两阶段提交协议如下图

 

bqual、formatID是可选的。解释如下：

gtrid : 是一个全局事务标识符(global transaction identifier)，

bqual:是一个分支限定符(branch qualifier)，如果没有提供bqual，那么默认值为空字符串''。

formatID：是一个数字，用于标记gtrid和bqual值的格式，这是一个无符号整数(unsigned integer)，也就是说，最小为0。如果没有提供formatID，那么其默认值为1。

class JdbcTest {

	private XADataSource mysqlDS;
	private XADataSource oraDS;

	@BeforeEach
	void setUp() throws Exception {
		ApplicationContext context = new ClassPathXmlApplicationContext("base_jdbc.xml");
		this.mysqlDS = context.getBean("mysql_oracle_ds", XADataSource.class);
		this.oraDS = context.getBean("oracle_sources_ds", XADataSource.class);
	}

	private void output(Object obj) {
		System.out.println(obj);
	}

	@Test
	void testXATransaction() throws Exception {
		XAConnection mysqlXaConn = this.mysqlDS.getXAConnection();
		XAConnection oraXaConn = this.oraDS.getXAConnection();
		XAResource mysqlXaRes = mysqlXaConn.getXAResource();
		XAResource oraXaRes = oraXaConn.getXAResource();
		byte[] gtrid = "g12345".getBytes();
		int formateId = 1;
		byte[] mysqlBqual = "b00001".getBytes();
		Xid mysqlXID = new MysqlXid(gtrid, mysqlBqual, formateId);
		byte[] oraBqual = "b00002".getBytes();
		Xid oraXID = new OracleXid(formateId, gtrid, oraBqual);
		try (Connection mysqlConn = mysqlXaConn.getConnection(); Connection orclConn = oraXaConn.getConnection();) {
			mysqlXaRes.start(mysqlXID, XAResource.TMNOFLAGS);
			Statement mysqlStat = mysqlConn.createStatement();
			String usql = "update LOGIN_LOG set USERNAME=UUID() WHERE ID ='ka==2245555'";
			mysqlStat.executeUpdate(usql);
			mysqlXaRes.end(mysqlXID, XAResource.TMSUCCESS);

			oraXaRes.start(oraXID, XAResource.TMNOFLAGS);
			Statement orclStat = orclConn.createStatement();
			String updateSql = "update  LOGIN_LOG w set w.USERNAME=SYS_GUID() WHERE w.ID ='a123'";
			orclStat.executeUpdate(updateSql);
			oraXaRes.end(oraXID, XAResource.TMSUCCESS);
		} catch (Exception e) {
			e.printStackTrace();
			mysqlXaRes.rollback(mysqlXID);
			oraXaRes.rollback(oraXID);
			return;
		}
		boolean onePhase = false; //TM判断有2个事务分支，所以不能优化为一阶段提交
		try {
			int mysqlPrepare = mysqlXaRes.prepare(mysqlXID);
			int oraPrepare = oraXaRes.prepare(oraXID);
			if (mysqlPrepare == XAResource.XA_OK && oraPrepare == XAResource.XA_OK) {
				mysqlXaRes.commit(mysqlXID, onePhase);
				oraXaRes.commit(oraXID, onePhase);
				assertTrue(true);
			} else {
				mysqlXaRes.rollback(mysqlXID);
				oraXaRes.rollback(oraXID);
				assertTrue(false);
			}
		} catch (Exception e) {
			e.printStackTrace();
			mysqlXaRes.rollback(mysqlXID);
			oraXaRes.rollback(oraXID);
		}
		this.output("finish----");
	}

}