最近需要用到分布式事务，研究了下jta，使用了atomikos这个jta的实现，使用的是spring3.0，废话少说，直接贴代码。
1.使用如下jar包
atomikos-util.3.7.0.jar
cglib-nodep-2.2.2.jar
transactions-3.7.0.jar
transactions-api-3.7.0.jar
transactions-jdbc-3.7.0.jar
transactions-jta-3.7.0.jar
2.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:jee="http://www.springframework.org/schema/jee"
xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd"
default-lazy-init="true">
<context:component-scan base-package="com.atom.jta.test" />
<!-- atomikos事务管理器 -->
<bean id="atomikosTransactionManager" class="com.atomikos.icatch.jta.UserTransactionManager"
init-method="init" destroy-method="close">
<description>UserTransactionManager</description>
<property name="forceShutdown">
<value>true</value>
</property>
</bean>
<bean id="atomikosUserTransaction" class="com.atomikos.icatch.jta.UserTransactionImp">
<property name="transactionTimeout" value="300" />
</bean>
<!-- spring 事务管理器 -->
<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">
</property>
</bean>
<!-- 事务拦截器 -->
<bean id="transactionInterceptor"
class="org.springframework.transaction.interceptor.TransactionInterceptor">
<!-- 配置事务管理器 -->
<property name="transactionManager" ref="springTransactionManager" />
<!-- 方法名：要求的事务属性 -->
<property name="transactionAttributes">
<props>
<prop key="insertTest">PROPAGATION_REQUIRED,ISOLATION_REPEATABLE_READ,-Throwable
</prop>
</props>
</property>
</bean>
<bean
class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
<property name="beanNames">
<list>
<value>atomTransactionServiceImpl</value>
</list>
</property>
<property name="interceptorNames">
<list>
<value>transactionInterceptor</value>
</list>
</property>
</bean>
</beans>
2.数据源:
datasource1:
package com.atom.jta.test;
import java.util.Properties;
import org.springframework.stereotype.Repository;
import com.atomikos.jdbc.AtomikosDataSourceBean;
@Repository
public class MasterAtomDatasource extends AtomikosDataSourceBean {
private static final long serialVersionUID = -2471230875536339311L;
public MasterAtomDatasource(){
Properties prop = new Properties();
prop.put("user", "root");
prop.put("password", "");
prop.put("URL", "jdbc:mysql://127.0.0.1:3306/test?autoReconnect=true");
setXaDataSourceClassName("com.mysql.jdbc.jdbc2.optional.MysqlXADataSource");
setUniqueResourceName("mysql_ds1");
setPoolSize(5);
setXaProperties(prop);
}
}
datasource2:
package com.atom.jta.test;
import java.util.Properties;
import org.springframework.stereotype.Repository;
import com.atomikos.jdbc.AtomikosDataSourceBean;
@Repository
public class SlaveAtomDataSource extends AtomikosDataSourceBean {
private static final long serialVersionUID = -6210394799199416765L;
public SlaveAtomDataSource(){
Properties prop = new Properties();
prop.put("user", "root");
prop.put("password", "");
prop.put("URL", "jdbc:mysql://127.0.0.1:3306/test1?autoReconnect=true");
setXaDataSourceClassName("com.mysql.jdbc.jdbc2.optional.MysqlXADataSource");
setUniqueResourceName("mysql_ds2");
setPoolSize(5);
setXaProperties(prop);
}
}
3.BaseDao:
package com.atom.jta.test;
import javax.annotation.Resource;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
@Repository
public class AtomBaseDao {
private JdbcTemplate mastTemplate;
private JdbcTemplate slaveTemplate;
public JdbcTemplate getMastTemplate() {
return mastTemplate;
}
@Resource(name="masterAtomDatasource")
public void setMastTemplate(DataSource source) {
this.mastTemplate = new JdbcTemplate(source);
}
public JdbcTemplate getSlaveTemplate() {
return slaveTemplate;
}
@Resource(name="slaveAtomDataSource")
public void setSlaveTemplate(DataSource source) {
this.slaveTemplate = new JdbcTemplate(source);
}
}
4.测试service
package com.atom.jta.test;
import org.springframework.context.ApplicationContext;
public interface AtomTransactionService {
public void insertTest(ApplicationContext ctx) throws Exception;
}
package com.atom.jta.test;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Service;
@Service
public class AtomTransactionServiceImpl implements AtomTransactionService {
public void insertTest(ApplicationContext ctx) throws Exception {
AtomBaseDao baseDao = ctx.getBean(AtomBaseDao.class);
String str = "xxxx";
String masterSql = "insert into demo (name) values "+"('"+str+"')";
String slaveSql = "insert into test (name) values "+"('"+str+"')";
baseDao.getMastTemplate().execute(masterSql);
baseDao.getSlaveTemplate().execute(slaveSql);
throw new Exception();
}
}
5.事务测试
package com.atom.jta.test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class AtomTest {
public AtomTest(){
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext-atomikos.xml");
AtomTransactionService service = ctx.getBean(AtomTransactionService.class);
try {
service.insertTest(ctx);
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
AtomTest test = new AtomTest();
System.out.println("done.....");
}
}
就是如此简单
相关推荐
本项目“spring+jotm+ibatis+mysql实现JTA分布式事务”旨在利用这些技术来确保在分布式环境中的数据一致性。下面将详细介绍这个项目所涉及的知识点。 首先，Spring框架是Java开发中最常用的应用框架之一，它提供了...
本文将详细讲解如何利用Spring Boot、Atomikos、JPA（Java Persistence API）以及MySQL来实现JTA（Java Transaction API）分布式事务。 首先，Spring Boot是一个轻量级的框架，它简化了基于Spring的应用程序开发...
例子虽小，可覆盖面广，设计spring载入.properties文件，spring配置jta和jotm分布式事务，设置数据源连接池，注解事务驱动。功能是在mysql上建立了两个数据库分别为dbone和dbtwo,在dbone里有表tb1,表中只有一个字段...
本教程将详细讲解如何使用Spring Boot、Druid和Mybatis来实现JTA（Java Transaction API）分布式事务。这是一项高级技术，它允许在多数据库环境或者微服务架构中进行一致性的数据操作。 首先，让我们了解什么是JTA...
在分布式系统中，确保事务的...配置包括设置Atomikos事务管理器、数据源以及事务属性，然后在业务逻辑中利用Spring的`@Transactional`注解来管理事务边界。这使得开发者能够在复杂分布式环境中实现高一致性的业务逻辑。
1. Atomikos：这是一个开源的JTA实现，提供了一种在Spring Boot中实现分布式事务的方式。 2. Bitronix：另一种JTA实现，也可以与Spring Boot集成，处理分布式事务。 要启用JTA事务管理，你需要： 1. 添加Atomikos...
Atomikos则是开源的JTA（Java Transaction API）实现，能够提供分布式事务解决方案。本文将深入探讨如何使用Spring、MyBatis和Atomikos实现JTA分布式事务。 首先，让我们理解JTA的概念。Java Transaction API（JTA...
Spring、Hibernate和JTA（Java Transaction API）是Java开发者在构建分布式事务解决方案时常用的三大技术。本示例“第二部分spring+hibernate+jta 分布式事务Demo”将帮助我们理解如何在这三个框架之间协同工作，...
总结来说，Atomikos 为 Spring 提供了强大的分布式事务管理能力，通过配置 Atomikos 事务管理器、JTA 数据源，以及启用声明式事务管理，我们可以轻松地在多数据源环境中实现事务一致性。在实际项目中，还可以根据...
Atomikos 是一个开源的JTA实现，它为Spring提供了一个轻量级、高性能的分布式事务解决方案。本文将深入探讨如何使用Spring、JTA和Atomikos来实现分布式事务。 首先，了解JTA的基本概念。JTA定义了一套规范，允许在...
本文将深入探讨如何在Tomcat应用服务器上集成JTA，并使用JOTM（Java Open Transaction Manager）或Atomikos作为事务管理器来实现分布式事务。 首先，我们需要理解JTA的核心概念。JTA是Java EE平台的一部分，提供了...
Atomikos是一款开源的Java事务管理器，它实现了JTA（Java Transaction API）规范，能够支持跨多个数据库的分布式事务。 Spring Boot集成Atomikos进行分布式事务管理，主要步骤包括： 1. 引入依赖：在项目中添加...
同时，还需要考虑与JTA事务管理器（如Atomikos、Bitronix等）的集成，以实现完整的分布式事务处理。 总结来说，XAPool是JTA分布式事务处理的重要组件，提供了一种高效的数据库连接池解决方案，对于构建大规模、高...
5. **Atomikos**: Atomikos是一个开源的JTA（Java Transaction API）实现，它为分布式事务提供了强大的支持。Atomikos可以管理多个数据库和消息队列的事务，确保在一个分布式系统中所有资源的更新要么全部成功，要么...
JTA（Java Transaction API）是Java平台上的一个标准接口，用于处理分布式事务，它允许应用程序在不同的数据源之间进行协调，确保事务的ACID特性（原子性、一致性、隔离性和持久性）。本示例代码旨在展示如何在Java...
2.Spring+Jotm整合实现JTA分布式事务，应用场景如转账等，同一事务内完成db1用户加100元、db2用户减100元。 3.Spring+Junit4单元测试，优点：不会破坏数据库现场，等等。 （特别注意：Spring3.0里不在提供对jotm的...
jta Springboot + Atomikos + Druid + Mysql 实现JTA分布式事务 问题一：Druid 和 Mysql 版本的问题 问题二：Springtest 默认情况下事务回滚 Mysql对XA协议支持不好，有待看
Atomikos是一款开源的事务处理监控器（TPM），它实现了JTA（Java Transaction API），提供了一种在分布式环境中协调事务的方法。JTA是Java EE的一部分，定义了在分布式环境中进行事务管理的标准接口。 在SpringBoot...
5. **配置Spring事务管理器**：创建Atomikos事务管理器的bean，并配置Spring的PlatformTransactionManager，指定使用Atomikos的UserTransaction。 6. **代码实现**：在业务逻辑中，通过Spring的@Transactional注解...