`
星夜的遐想
  • 浏览: 186813 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

Atomikos实现分布式事务开发小结

阅读更多

由于项目中用到了操作多个数据库,并且要在通过Service方法里面完成,为了保证事务同步,引用了Atomikos,可参考http://www.atomikos.com/Documentation/。

 

1、加入Atomikos的相关类库,Maven项目中配置如下:  

 

<dependency>
	<groupId>com.atomikos</groupId>
	<artifactId>transactions-jdbc</artifactId>
	<version>3.7.0</version>
</dependency>

 

2、配置数据源,使用atomikos自带的datasource实现类,如AtomikosNonXADataSourceBean,AtomikosDataSourceBean等,经测试AtomikosDataSourceBean这类对数据库的要求挺多的,特别是Oracle,于是采用AtomikosNonXADataSourceBean。我配置了一个MySQL数据源,一个Oracle数据源如下:

 

<bean id="mysqlDS" class="com.atomikos.jdbc.nonxa.AtomikosNonXADataSourceBean" init-method="init"
		destroy-method="close" p:uniqueResourceName="mysql_ds" p:testQuery="select 1 ">
		<property name="driverClassName" value="${mysql.connection.driverClass}" />
		<property name="url" value="${mysql.connection.url}" />
		<property name="user" value="${mysql.connection.username}" />
		<property name="password" value="${mysql.connection.password}" />
		<property name="poolSize" value="5" />
		<property name="maxPoolSize" value="30" />
	</bean>
	
	<bean id="oracleDS" class="com.atomikos.jdbc.nonxa.AtomikosNonXADataSourceBean" init-method="init"
		destroy-method="close" p:uniqueResourceName="oracle_ds" p:testQuery="select 1 from dual ">
		<property name="driverClassName" value="${oracle.connection.driverClass}" />
		<property name="url" value="${oracle.connection.url}" />
		<property name="user" value="${oracle.connection.username}" />
		<property name="password" value="${oracle.connection.password}" />
		<property name="poolSize" value="5" />
		<property name="maxPoolSize" value="30" />
	</bean>

 

3、配置SessionFacotry ,不同的数据源对应不同的SessionFacotry.

	<bean id="mySqlSessionFactory"
		class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">

		<property name="dataSource" ref="mysqlDS" />
		<property name="packagesToScan">
			<list>
				<value>com.lyl.**.entity</value>
			</list>
		</property>
		<property name="entityInterceptor">
			<bean class="com.lyl.base.BaseDaoInterceptor"></bean>
		</property>
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">${mysql.dialect}</prop>
				<prop key="hibernate.hbm2ddl.auto">${mysql.hbm2ddl.auto}</prop>
				<prop key="hibernate.jdbc.fetch_size">50</prop>
				<prop key="hibernate.jdbc.batch_size">20</prop>
				<prop key="hibernate.query.factory_class">org.hibernate.hql.ast.ASTQueryTranslatorFactory
				</prop>
				<prop key="hibernate.jdbc.use_scrollable_resultset">false</prop>
				<prop key="hibernate.use_outer_join">true</prop>
				<prop key="hibernate.show_sql">false</prop>
				<prop key="hibernate.format_sql">true</prop>
				<prop key="hibernate.cache.use_query_cache">true</prop>
				<prop key="hibernate.cache.provider_class">
					org.hibernate.cache.EhCacheProvider
				</prop>
			</props>
		</property>
	</bean>

	<bean id="oracleSessionFactory"
		class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">

		<property name="dataSource" ref="oracleDS" />
		<property name="packagesToScan">
			<list>
				<value>com.lyl.**.entity</value>
			</list>
		</property>
		<property name="entityInterceptor">
			<bean class="com.lyl.base.BaseDaoInterceptor"></bean>
		</property>
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">${oracle.dialect}</prop>
				<prop key="hibernate.hbm2ddl.auto">${oracle.hbm2ddl.auto}</prop>
				<prop key="hibernate.jdbc.fetch_size">50</prop>
				<prop key="hibernate.jdbc.batch_size">20</prop>
				<prop key="hibernate.query.factory_class">org.hibernate.hql.ast.ASTQueryTranslatorFactory
				</prop>
				<prop key="hibernate.jdbc.use_scrollable_resultset">false</prop>
				<prop key="hibernate.use_outer_join">true</prop>
				<prop key="hibernate.show_sql">false</prop>
				<prop key="hibernate.format_sql">true</prop>
				<prop key="hibernate.cache.use_query_cache">true</prop>
				<prop key="hibernate.temp.use_jdbc_metadata_defaults">false</prop>
				<prop key="hibernate.cache.provider_class">
					org.hibernate.cache.EhCacheProvider
				</prop>
			</props>
		</property>
	</bean>

 

4、配置事务管理。

根据需要配置了两个数据库事务,一个管理单个数据库操作,另一个管理多个数据库操作,配置不同的切面,针对不同的类,采取不同的事务方式。

 

	<bean id="baseTransactionManager"
		class="org.springframework.orm.hibernate3.HibernateTransactionManager">
		<property name="sessionFactory" ref="mySqlSessionFactory" />
	</bean>
	
	
	<tx:advice id="baseTxAdvice" transaction-manager="baseTransactionManager">
		<tx:attributes>
			<tx:method name="get*" read-only="true" />
			<tx:method name="query*" read-only="true" />
			<tx:method name="find*" read-only="true" />
			<tx:method name="load*" read-only="true" />
			<tx:method name="*" propagation="REQUIRED" />
		</tx:attributes>
	</tx:advice>

	<aop:config proxy-target-class="true">
		<aop:advisor pointcut="execution(* com.lyl..*Service.*(..))"
			advice-ref="baseTxAdvice" />
	</aop:config>

 

  

<bean id="atomikosTransactionManager" class="com.atomikos.icatch.jta.UserTransactionManager"
		init-method="init" destroy-method="close">
		<property name="forceShutdown" value="true" />
	</bean>

	<bean id="atomikosUserTransaction" class="com.atomikos.icatch.jta.UserTransactionImp">
		<property name="transactionTimeout" value="300" />
	</bean>

	<!-- JTA事务管理器 -->
	<bean id="jtaTransactionManager"
		class="org.springframework.transaction.jta.JtaTransactionManager">
		<property name="transactionManager" ref="atomikosTransactionManager" />
		<property name="userTransaction" ref="atomikosUserTransaction" />
	</bean>

	
	<tx:advice id="jtaTxAdvice" transaction-manager="jtaTransactionManager">
		<tx:attributes>
			<tx:method name="get*" read-only="true" />
			<tx:method name="query*" read-only="true" />
			<tx:method name="find*" read-only="true" />
			<tx:method name="load*" read-only="true" />
			<tx:method name="*" propagation="REQUIRED" />
		</tx:attributes>
	</tx:advice>

	<aop:config proxy-target-class="true">
		<aop:advisor pointcut="execution(* com.lyl..*Biz.*(..))"
			advice-ref="jtaTxAdvice" />
	</aop:config>

 

  5、配置两个操作不同数据库DAO类。

 

 

 

<bean id="mySqlHibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
		<constructor-arg name="sessionFactory">
			<ref bean="mySqlSessionFactory" />
		</constructor-arg>
	</bean>

	<bean id="oracleHibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
		<constructor-arg name="sessionFactory">
			<ref bean="oracleSessionFactory" />
		</constructor-arg>
	</bean>

	<bean id="mySqlBaseDao" class="com.lyl.base.BaseDao">
		<property name="hibernateTemplate" ref="mySqlHibernateTemplate"></property>
	</bean>

	<bean id="oracleBaseDao" class="com.lyl.base.BaseDao">
		<property name="hibernateTemplate" ref="oracleHibernateTemplate"></property>
	</bean>

 

 

6、需要执行分布式事务的Service类。

 

@Service
public class AccountBiz {
	
	@Resource
	private BaseDao mySqlBaseDao;
	
	@Resource
	private BaseDao oracleBaseDao;

	public void transer(Double amount) {
		Account_A a=new  Account_A();
		a.setAid(1L);
		Account_A aa=(Account_A)mySqlBaseDao.findById(a);
		Account_B b=new  Account_B();
		b.setBid(1L);
		Account_B bb=(Account_B)oracleBaseDao.findById(b);
		//bb.setIdNo("88888888");
		Date date=new Date();
		aa.setOpDate(date);
		aa.setAmount(aa.getAmount()+amount);
		bb.setOpDate(date);
		bb.setAmount(bb.getAmount()-amount);
		
		mySqlBaseDao.update(aa);
		oracleBaseDao.update(bb);
	}
	
	
}

 

 

 

 

 

 

 

 

 

 

 

分享到:
评论

相关推荐

    Atomikos实现分布式事务

    总结来说,"Atomikos实现分布式事务"是一个关键的技术实践,它利用Java的JTA标准,结合Atomikos库,实现了在Web项目中对多个数据库进行统一的事务管理,确保了业务操作的原子性和一致性,从而提高了系统整体的可靠性...

    java+spring+mybatis+mysql+RuoYi-atomikos-实现分布式事务.zip

    本项目"java+spring+mybatis+mysql+RuoYi-atomikos-实现分布式事务.zip"是一个基于若依(RuoYi)框架改造的多模块分布式事务解决方案,它利用了Atomikos这一强大的分布式事务管理器。以下将详细解析这个项目的知识点...

    使用Spring+atomikos实现分布式事务

    在分布式系统中,确保事务的...配置包括设置Atomikos事务管理器、数据源以及事务属性,然后在业务逻辑中利用Spring的`@Transactional`注解来管理事务边界。这使得开发者能够在复杂分布式环境中实现高一致性的业务逻辑。

    集成atomikos实现分布式事务.zip

    3. **创建Atomikos事务管理器**: 在Spring Boot的配置类中,创建AtomikosUserTransactionManager和AtomikosDataSourceBean实例,并注册为Spring Bean。这样,Spring会自动管理这些事务资源。 4. **配置Spring的事务...

    spring + JTA + atomikos 实现分布式事务

    Atomikos 是一个开源的JTA实现,它为Spring提供了一个轻量级、高性能的分布式事务解决方案。本文将深入探讨如何使用Spring、JTA和Atomikos来实现分布式事务。 首先,了解JTA的基本概念。JTA定义了一套规范,允许在...

    spring4+atomikos实现分布式事务

    在这个案例中,我们将深入探讨如何使用Spring 4与Atomikos来实现跨数据库的分布式事务管理。 Atomikos是一款开源的事务处理监控器(Transaction Processing Monitor,TPM),它支持JTA(Java Transaction API)标准...

    集成jta-atomikos 实现分布式事务.zip

    配置完成后,我们需要创建一个Spring配置类,用于初始化Atomikos事务管理器,并注册到Spring容器中。例如: ```java @Configuration public class AtomikosConfig { @Bean public UserTransactionImp ...

    spring mybatis atomikos 多库分布式事务demo

    本示例“spring mybatis atomikos 多库分布式事务demo”聚焦于如何在Spring与MyBatis框架下利用Atomikos实现跨数据库的分布式事务管理。 首先,Spring是一个广泛应用的开源框架,提供了丰富的功能,包括依赖注入、...

    非Maven基于SSM+Atomikos的分布式事务处理案例源码

    Atomikos事务管理器会根据配置自动管理和提交事务。 9. 测试:为了验证事务处理的正确性,可以设计一系列测试用例,模拟并发操作,观察事务处理是否满足预期。 最后,关于**XA**: 10. XA协议:这是一种分布式...

    SpringBoot+Atomikos分布式事务及多数据源动态切换,两种demo

    Spring Boot作为轻量级的Java开发框架,结合Atomikos这样的分布式事务管理器,可以有效地解决这些问题。本文将深入探讨如何在Spring Boot项目中实现Atomikos分布式事务以及动态数据源切换的两种示例。 首先,我们...

    springboot-jpa atomikos 分布式事务管理

    本文将详细讲解"springboot-jpa atomikos 分布式事务管理"这一主题,以及如何在SpringBoot 2.0.5版本中结合JPA、Hibernate和MyBatis实现多数据库事务控制。 首先,SpringBoot是一个简化Spring应用开发的框架,它...

    Atomikos分布式事务DEMO

    Atomikos分布式事务DEMO是一个基于Spring、MyBatis、MySQL和Tomcat的示例项目...通过这个DEMO,你可以学习到Spring、MyBatis、MySQL和Atomikos在分布式事务场景下的协同工作方式,对于提升企业级应用开发技能大有裨益。

    spring整合atomikos实现分布式事务的方法示例

    Spring 整合 Atomikos 实现分布式事务是解决在分布式环境下多个数据库操作一致性问题的关键技术。Atomikos 是一个开源的事务管理器,它为 Java 平台提供了强大的支持,特别是处理跨越多个数据库的事务需求。在分布式...

    spring JTA集成JOTM或Atomikos配置分布式事务(Tomcat应用服务器)

    本文将深入探讨如何在Tomcat应用服务器上集成JTA,并使用JOTM(Java Open Transaction Manager)或Atomikos作为事务管理器来实现分布式事务。 首先,我们需要理解JTA的核心概念。JTA是Java EE平台的一部分,提供了...

    spring+atomikos+druid分布式事务Demo

    在Spring中,我们可以通过配置Atomikos事务管理器,使得Spring可以在跨数据库操作时启动和管理全局事务。 Druid是一个强大的数据库连接池,它不仅提供了高效的连接管理和性能监控,还支持分布式事务。在Spring和...

    atomikos分布式事务提交框架

    总的来说,Atomikos分布式事务提交框架是Java开发者在构建高可用、高并发系统时的重要工具,它简化了分布式事务的实现,增强了系统的可靠性和一致性。在使用过程中,配合Spring框架,可以更便捷地管理和控制事务,...

    Spring3.0+Hibernate+Atomikos多数据源分布式事务管理

    2. 创建Atomikos事务管理器bean,并将其设置为Spring的PlatformTransactionManager。 3. 使用Spring的@TransactionManagement注解启用声明式事务管理。 4. 在服务层方法上添加@Transactional注解,指定需要参与事务...

    Spring+MyBatis+Atomikos实现JTA分布式事务

    Atomikos则是开源的JTA(Java Transaction API)实现,能够提供分布式事务解决方案。本文将深入探讨如何使用Spring、MyBatis和Atomikos实现JTA分布式事务。 首先,让我们理解JTA的概念。Java Transaction API(JTA...

    Springboot+Atomikos+Jpa+Mysql实现JTA分布式事务

    本文将详细讲解如何利用Spring Boot、Atomikos、JPA(Java Persistence API)以及MySQL来实现JTA(Java Transaction API)分布式事务。 首先,Spring Boot是一个轻量级的框架,它简化了基于Spring的应用程序开发...

    springboot jta atomikos实现分布式事物管理

    SpringBoot JTA Atomikos 实现分布式事务管理 SpringBoot JTA Atomikos 是一种实现分布式事务管理的解决方案,它能够将多个数据库的事务统一管理起来,从而解决多个数据库之间的事务问题。在本篇文章中,我们将...

Global site tag (gtag.js) - Google Analytics