Spring实现分布式事务JTA(使用atomiko实现)

分布式事务是指事务的参与者、支持事务的服务器、资源管理器以及事务管理器分别位于分布系统的不同节点之上，在两个或多个网络计算机资源上访问并且更新数据，将两个或多个网络计算机的数据进行的多次操作作为一个整体进行处理。如不同银行账户之间的转账。

对于在项目中接触到JTA，大部分的原因是因为在项目中需要操作多个数据库，同时，可以保证操作的原子性，保证对多个数据库的操作一致性。

1、项目结构图：

2、pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

<groupId>org.nercita.ltxx</groupId>

<artifactId>jtaTest</artifactId>

<version>0.0.1-SNAPSHOT</version>

<name>jtaTest</name>

<url>http://maven.apache.org</url>

<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

<spring.version>4.1.6.RELEASE</spring.version>

</properties>

<groupId>junit</groupId>

<artifactId>junit</artifactId>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-test</artifactId>

<version>${spring.version}</version>

<scope>provided</scope>

</dependency>

<groupId>mysql</groupId>

<artifactId>mysql-connector-java</artifactId>

</dependency>

<groupId>com.oracle</groupId>

<artifactId>ojdbc6</artifactId>

</dependency>

<groupId>com.atomikos</groupId>

<artifactId>transactions-jdbc</artifactId>

</dependency>

<groupId>javax.transaction</groupId>

</dependency>

<groupId>javax</groupId>

<artifactId>javaee-api</artifactId>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-context</artifactId>

<version>${spring.version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-jdbc</artifactId>

<version>${spring.version}</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-aspects</artifactId>

<version>${spring.version}</version>

</dependency>

<groupId>org.aspectj</groupId>

<artifactId>aspectjweaver</artifactId>

</dependency>

<groupId>org.aspectj</groupId>

<artifactId>aspectjrt</artifactId>

</dependency>

</dependencies>

</project>

2、applicationContext.xml

100

101

102

103

104

105

106

107

108

109

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

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:aop="http://www.springframework.org/schema/aop"

xmlns:context="http://www.springframework.org/schema/context"

xmlns:jee="http://www.springframework.org/schema/jee"

xmlns:tx="http://www.springframework.org/schema/tx"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd

http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-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/jee http://www.springframework.org/schema/jee/spring-jee-4.0.xsd

http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd">

<context:property-placeholder location="classpath*:/application.properties" />

<context:spring-configured />

<context:component-scan base-package="org.nercita.ltxx.jtatest" />

<bean id="masterDataSource" class="com.atomikos.jdbc.AtomikosDataSourceBean"

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

<description>master xa datasource</description>

<value>masterDataSource</value>

</property>

<props>

<prop key="URL">jdbc:mysql://127.0.0.1:3306/master</prop>

</props>

</property>

</bean>

<bean id="slaveDataSource" class="com.atomikos.jdbc.AtomikosDataSourceBean"

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

<description>slave xa datasource</description>

<value>slaveDataSource</value>

</property>

<props>

<prop key="URL">jdbc:mysql://127.0.0.1:3306/slave</prop>

</props>

</property>

</bean>

<bean id="atomikosTransactionManager" class="com.atomikos.icatch.jta.UserTransactionManager"

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

<description>UserTransactionManager</description>

</property>

</bean>

</bean>

</property>

</property>

</bean>

</property>

</bean>

<constructor-arg>

</constructor-arg>

</bean>

<constructor-arg>

</constructor-arg>

</bean>

<tx:annotation-driven transaction-manager="springTransactionManager"/>

</beans>

ps：数据库和表需自行创建

3、java类

dao：

package org.nercita.ltxx.jtatest.dao;

import javax.annotation.Resource;

import org.springframework.jdbc.core.JdbcTemplate;

import org.springframework.stereotype.Repository;

@Repository

public class JtaTestMasterDao{

@Resource(name="masterJdbcTemplate")

JdbcTemplate masterJdbcTemplate;

public String master() {

masterJdbcTemplate.execute("update teacher set name='master' where id=1");

return "success";

}

public void update() {

masterJdbcTemplate.execute("update teacher set name='8' where id=1");

System.out.println("update");

masterJdbcTemplate.execute("fff teacher set name=''6' where id=1");

}

package org.nercita.ltxx.jtatest.dao;

import javax.annotation.Resource;

import org.springframework.jdbc.core.JdbcTemplate;

import org.springframework.stereotype.Repository;

@Repository

public class JtaTestSlaveDao{

@Resource(name="slaveJdbcTemplate")

JdbcTemplate slaveJdbcTemplate;

public String slave() {

slaveJdbcTemplate.execute("update student set name='slave' where id=1");

return "success";

}

service：

100

101

102

package org.nercita.ltxx.jtatest.service;

import javax.annotation.Resource;

import javax.transaction.SystemException;

import javax.transaction.UserTransaction;

import org.nercita.ltxx.jtatest.dao.JtaTestMasterDao;

import org.nercita.ltxx.jtatest.dao.JtaTestSlaveDao;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import org.springframework.transaction.TransactionStatus;

import org.springframework.transaction.annotation.Transactional;

import org.springframework.transaction.jta.JtaTransactionManager;

import org.springframework.transaction.support.TransactionCallback;

import org.springframework.transaction.support.TransactionCallbackWithoutResult;

import org.springframework.transaction.support.TransactionTemplate;

@Service

public class JtaTestService{

@Resource(name = "springTransactionManager")

private JtaTransactionManager txManager;

@Autowired

private JtaTestMasterDao jtaTestMasterDao;

@Autowired

private JtaTestSlaveDao jtaTestSlaveDao;

@Resource(name = "transactionTemplate")

private TransactionTemplate transactionTemplate;

//编程式

public String test() {

UserTransaction userTx = txManager.getUserTransaction();

try {

userTx.begin();

jtaTestMasterDao.master();

jtaTestSlaveDao.slave();

int a=1/0;

System.out.println(a);

userTx.commit();

} catch (Exception e) {

System.out.println("捕获到异常，进行回滚" + e.getMessage());

e.printStackTrace();

try {

userTx.rollback();

} catch (IllegalStateException e1) {

System.out.println("IllegalStateException:" + e1.getMessage());

} catch (SecurityException e1) {

System.out.println("SecurityException:" + e1.getMessage());

} catch (SystemException e1) {

System.out.println("SystemException:" + e1.getMessage());

}

return null;

}

//声明式

@Transactional

public void update(){

jtaTestMasterDao.master();

int a=1/0;

System.out.println(a);

jtaTestSlaveDao.slave();

}

//事务模板方式

public void test3() {

transactionTemplate.execute(new TransactionCallbackWithoutResult(){

@Override

protected void doInTransactionWithoutResult(TransactionStatus status) {

try {

jtaTestMasterDao.master();

jtaTestSlaveDao.slave();

int a=1/0;

System.out.println(a);

} catch (Exception ex) {

// 通过调用 TransactionStatus 对象的 setRollbackOnly() 方法来回滚事务。

status.setRollbackOnly();

ex.printStackTrace();

}

});

//有返回值的回调

Object obj=transactionTemplate.execute(new TransactionCallback(){

@Override

public Object doInTransaction(TransactionStatus status) {

return 1;

}

});

}

controller(本文直接使用controller进行测试)

package org.nercita.ltxx.jtatest.web;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.nercita.ltxx.jtatest.service.JtaTestService;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Controller;

import org.springframework.test.context.ContextConfiguration;

import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration(locations = "classpath:applicationContext.xml")

@Controller

public class JtaTestController {

@Autowired

private JtaTestService jtaTestService;

//MySQL的数据库引擎必须是InnoDB，否则无法回滚

@Test

public void test(){

jtaTestService.test();

}

@Test

public void test2(){

jtaTestService.update();

}

@Test

public void test3(){

jtaTestService.test3();

}

4、数据源详细参数配置

<bean id="abstractXADataSource" class="com.atomikos.jdbc.AtomikosDataSourceBean" init-method="init"

destroy-method="close" abstract="true">

<value>select 1</value>

</property>

</bean>

<property name="xaDataSourceClassName"

value="com.mysql.jdbc.jdbc2.optional.MysqlXADataSource" />

<props>

<prop key="user">${jdbc.username}</prop>

<prop key="password">${jdbc.password}</prop>

</props>

</property>

</bean>

<property name="xaDataSourceClassName"

value="com.mysql.jdbc.jdbc2.optional.MysqlXADataSource" />

<props>

<prop key="URL">${jdbca.url}</prop>

<prop key="user">${jdbca.username}</prop>

<prop key="password">${jdbca.password}</prop>

</props>

</property>

</bean>

发表回复 取消回复

发表回复取消回复