`

JTA事物

 
阅读更多

applicationContext.xml

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
	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:task="http://www.springframework.org/schema/task"
	xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.2.xsd">

	<context:component-scan base-package="com.ajita.*" />
	<tx:annotation-driven />
	<tx:jta-transaction-manager />

	<bean id="dataSourceA" class="com.atomikos.jdbc.AtomikosDataSourceBean"
		init-method="init" destroy-method="close">
		<property name="uniqueResourceName">
			<value>DataSourceA</value>
		</property>
		<property name="xaDataSourceClassName">
			<value>com.mysql.jdbc.jdbc2.optional.MysqlXADataSource</value>
		</property>
		<property name="xaProperties">
			<props>
				<prop key="databaseName">test</prop>
				<prop key="serverName">127.0.0.1</prop>
				<prop key="port">3306</prop>
				<prop key="user">root</prop>
				<prop key="password">123456</prop>
				<prop key="url">jdbc:mysql://127.0.0.1:3306/test</prop>
			</props>
		</property>
		<property name="minPoolSize">
			<value>1</value>
		</property>
	</bean>

	<bean id="dataSourceB" class="com.atomikos.jdbc.AtomikosDataSourceBean"
		init-method="init" destroy-method="close">
		<property name="uniqueResourceName">
			<value>DataSourceB</value>
		</property>
		<property name="xaDataSourceClassName">
			<value>net.sourceforge.jtds.jdbcx.JtdsDataSource</value>
		</property>
		<property name="xaProperties">
			<props>
				<prop key="databaseName">SimpleDB</prop>
				<prop key="serverName">127.0.0.1</prop>
				<prop key="portNumber">1434</prop>
				<prop key="user">sa</prop>
				<prop key="password">123456</prop>
			</props>
		</property>
		<property name="minPoolSize">
			<value>1</value>
		</property>
	</bean>

	<bean id="entityManagerFactoryA"
		class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
		<property name="persistenceXmlLocation">
			<value>classpath*:persistence.xml</value>
		</property>
		<property name="persistenceUnitName" value="PersistenceUnitA" />
		<property name="dataSource" ref="dataSourceA" />
		<property name="jpaVendorAdapter">
			<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
				<property name="showSql" value="true" />
				<property name="databasePlatform" value="org.hibernate.dialect.MySQL5InnoDBDialect" />
			</bean>
		</property>
	</bean>

	<bean id="entityManagerFactoryB"
		class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
		<property name="persistenceXmlLocation">
			<value>classpath*:persistence.xml</value>
		</property>
		<property name="persistenceUnitName" value="PersistenceUnitB" />
		<property name="dataSource" ref="dataSourceB" />
		<property name="jpaVendorAdapter">
			<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
				<property name="showSql" value="true" />
				<property name="databasePlatform" value="org.hibernate.dialect.SQLServerDialect" />
			</bean>
		</property>
	</bean>

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

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

	<bean id="transactionManager"
		class="org.springframework.transaction.jta.JtaTransactionManager"
		depends-on="atomikosTransactionManager,atomikosUserTransaction">
		<property name="transactionManager" ref="atomikosTransactionManager" />
		<property name="userTransaction" ref="atomikosUserTransaction" />
		<property name="allowCustomIsolationLevels" value="true" />
	</bean>

</beans>

 persistence.xml

 

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0"
	xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/persistence 
  http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">

	<persistence-unit name="PersistenceUnitA"
		transaction-type="JTA">
		<class>com.ajita.jta.entity.MySqlUser</class>
		<properties>
			<property name="hibernate.transaction.manager_lookup_class"
				value="com.atomikos.icatch.jta.hibernate3.TransactionManagerLookup" />
			<property name="hibernate.transaction.factory_class"
				value="org.hibernate.transaction.CMTTransactionFactory" />
		</properties>
	</persistence-unit>

	<persistence-unit name="PersistenceUnitB"
		transaction-type="JTA">
		<class>com.ajita.jta.entity.SQLServerUser</class>
		<properties>
			<property name="hibernate.transaction.manager_lookup_class"
				value="com.atomikos.icatch.jta.hibernate3.TransactionManagerLookup" />
			<property name="hibernate.transaction.factory_class"
				value="org.hibernate.transaction.CMTTransactionFactory" />
		</properties>
	</persistence-unit>

</persistence>

 Main.java

 

package com.ajita.jta;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

import com.ajita.jta.service.UserService;

public class Main {

	public static void main(String[] args) {
		try {
			ApplicationContext ctx = new FileSystemXmlApplicationContext(
					"classpath:applicationContext.xml");
			UserService userService = ctx.getBean("userService",
					UserService.class);
			userService.saveUser("hwwang2222222222222", "123");
		} catch (Exception ex) {
			ex.printStackTrace();
		}
	}
}

 UserService.java

package com.ajita.jta.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.ajita.jta.dao.MySqlUserDao;
import com.ajita.jta.dao.SQLServerUserDao;
import com.ajita.jta.entity.MySqlUser;
import com.ajita.jta.entity.SQLServerUser;

@Service
public class UserService {
	@Autowired
	private MySqlUserDao mysqlJpaDao;
	@Autowired
	private SQLServerUserDao sqlserverJpaDao;
	
	@Transactional
	public boolean saveUser(String username,String password){
		MySqlUser user1=new MySqlUser();
		user1.setUsername(username);
		user1.setPassword(password);
		
		mysqlJpaDao.save(user1);
		
		SQLServerUser user2=new SQLServerUser();
		user2.setUsername(username);
		sqlserverJpaDao.save(user2);
		return true;
	}
}

 SQLServerUserDao.java

package com.ajita.jta.dao;

import java.util.Collection;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import org.springframework.stereotype.Repository;

@Repository("sqlserverJpaDao")
public class SQLServerUserDao {
	@PersistenceContext(unitName = "PersistenceUnitB")
	private EntityManager entityManager;

	public EntityManager getEntityManager() {
		return entityManager;
	}

	public void setEntityManager(EntityManager entityManager) {
		this.entityManager = entityManager;
	}

	public void save(Object entity) {
		entityManager.persist(entity);
	}

	public void update(Object entity) {
		entityManager.merge(entity);
	}

	public <T> void saveAll(Collection<T> entities) {
		for (T entity : entities) {
			save(entity);
		}
	}

	public void delete(Object entity) {
		entityManager.remove(entity);
	}

	public <T> void deleteAll(Collection<T> entities) {
		for (T entity : entities) {
			delete(entity);
		}
	}

}

 MySqlUserDao.java

package com.ajita.jta.dao;

import java.util.Collection;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import org.springframework.stereotype.Repository;

@Repository("mysqlJpaDao")
public class MySqlUserDao {
	@PersistenceContext(unitName = "PersistenceUnitA")
	private EntityManager entityManager;

	public EntityManager getEntityManager() {
		return entityManager;
	}

	public void setEntityManager(EntityManager entityManager) {
		this.entityManager = entityManager;
	}

	public void save(Object entity) {
		entityManager.persist(entity);
	}

	public void update(Object entity) {
		entityManager.merge(entity);
	}

	public <T> void saveAll(Collection<T> entities) {
		for (T entity : entities) {
			save(entity);
		}
	}

	public void delete(Object entity) {
		entityManager.remove(entity);
	}

	public <T> void deleteAll(Collection<T> entities) {
		for (T entity : entities) {
			delete(entity);
		}
	}

}

 SQLServerUser.java

package com.ajita.jta.entity;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "UserSyn")
public class SQLServerUser {
	@Id
	@Column(name = "ID")
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private int id;
	@Column(name = "Name")
	private String username;
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
}

 MySqlUser.java

package com.ajita.jta.entity;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "user_table")
public class MySqlUser {
	@Id
	@Column(name="ID")
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	private int id;
	@Column(name="UserName")
	private String username;
	@Column(name="Password")
	private String password;
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
}

 

 

分享到：
| spring中的事件传播
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Atomikos解决JTA事物用法实战

    Atomikos是一款强大的开源事务管理解决方案，专门为Java应用程序设计，实现了Java Transaction API (JTA)。JTA是Java平台企业版（Java EE）的一部分，它提供了分布式事务处理的能力，允许在多个数据源或服务之间进行...

    maven springboot jta mybatis 分布式事物

    在本项目中，"maven springboot jta mybatis 分布式事物" 是一个核心主题，这涉及到几个关键技术和概念，下面将详细解释这些知识点。 首先，`Maven` 是一个构建工具，它帮助开发者管理项目的依赖关系，构建流程以及...

    最新的JTA规范.pdf

    通过这一规范，JTA旨在为组件化企业级应用服务器环境提供一套统一且高效的事物处理框架。 JTA的主要目标是简化在复杂分布式环境下，跨多个资源管理器进行一致性和可靠性操作的过程。它通过定义一系列接口和协议，...

    Springboot 动态多数据源 jta分布式事务

    本资源针对的是Spring Boot动态多数据源和JTA（Java Transaction API）分布式事务的实现，对于初学者来说非常实用。下面我们将深入探讨这些知识点。 首先，让我们了解一下Spring Boot的多数据源。在许多业务场景下...

    spring+mybatis+jta实现多数据源的分布式事物（代码可以直接运行）

    综上所述，"spring+mybatis+jta实现多数据源的分布式事物"项目为开发者提供了一个实用的示例，帮助他们了解和掌握在实际应用中如何处理复杂的事务场景。通过这个项目，开发者可以学习到Spring的事务管理、MyBatis的...

    JTA事务源码示例

    如何处理跨库事物：spring + jtom 的jta事务是个很好的选择. 这个源码示例非常不错，包括所有的源码和jar包，下载后eclipse 或 myeclipse 导入就能用。 里面有详细的说明和注释，欢迎下载传播。有问题请在评价中...

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

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

    Java中JDBC事务与JTA分布式事务总结与区别

    Java中的事务管理是确保数据一致性的重要机制，主要分为三种类型：JDBC事务、JTA（Java Transaction API）事务以及容器事务。本文将重点探讨JDBC事务和JTA分布式事务的区别和应用场景。 首先，JDBC事务是基于数据库...

    Java Transaction API概述

    JTA(Java Transaction API)允许应用程序执行分布式事务处理--在两个或多个网络计算机资源上访问并且更新数据。JDBC驱动程序的JTA支持极大地增强了数据访问能力。本文的目的是要提供一个关于的Java事务处理API（JTA）...

    Jboss事物处理

    【Jboss事物处理】是企业级Java应用中的一项关键技术，主要关注的是在分布式环境中如何确保数据的一致性和完整性。在大型系统中，由于服务的分布式特性，事务处理变得尤为重要，它保证了即使在网络故障或系统崩溃的...

    跨多个数据库操作，同时连接两个一上的数据库，用事物关联起来

    为了保证数据的一致性，我们需要一种机制来协调这些数据库间的操作，这就是"用事物关联起来"的关键。 事务（Transaction）是数据库操作的基本单元，它确保一组操作要么全部成功，要么全部失败，避免出现部分完成的...

    （事物学习笔记二） 对Java事物的理解

    本文将深入探讨“事物学习笔记二”中关于Java事务的理解，旨在帮助读者更好地掌握这一关键概念。 首先，事务（Transaction）是数据库操作的基本单位，它确保一组数据库操作要么全部成功，要么全部失败，从而保证...

    事物JPA入门

    **事物（Transaction）JPA 入门** Java Persistence API（JPA）是Java平台上的一个标准，用于管理和持久化Java对象到关系数据库。它提供了一种面向对象的方式来处理数据库操作，使得开发人员可以避免直接编写SQL，...

    XA 多数据源分布式事物实现 java

    本项目"XA 多数据源分布式事物实现 java"提供了一个基于Java实现的分布式事务管理方案，适用于需要跨多个数据源进行事务操作的场景。 首先，我们要理解什么是XA。XA是由开放组（The Open Group）制定的一套分布式...

    java 事物处理的资源

    1. **Java Transaction API (JTA)**: JTA是Java平台企业版（Java EE）的一部分，提供了一个标准的API来管理分布式事务。通过JTA，应用程序可以控制跨越多个数据源（如数据库、消息队列等）的事务。JTA包含三个主要...

    Java事物设计策略

    在深入探讨前，我们先明确几个核心概念：事务、ACID特性、JTA（Java Transaction API）、JTS（Java Transaction Service）以及UserTransaction和TransactionManager接口。 ### 事务与ACID特性 事务在数据库中被...

    事物管理javaweb.zip

    Java Transaction API（JTA）和Java Transaction Service（JTS）提供了一种处理分布式事务的标准。 8. **补偿事务（Saga）**：在微服务架构中，由于单个事务可能涉及多个服务，因此出现了Saga模式，它通过一系列小...

    java事务处理

    2. **JTA（Java Transaction API）事务管理**：用于分布式事务处理，通常与J2EE应用服务器一起使用。 #### 二、JDBC事务管理 JDBC（Java Database Connectivity）是Java中用于连接数据库的标准接口。在JDBC中，...

    atomikos 事物管理器

    在Java应用程序中，特别是在企业级应用服务（EJBs）、JMS、JTA以及Spring框架中，Atomikos事务管理器扮演着至关重要的角色。它实现了Java Transaction API (JTA)，允许开发者在多资源、多数据库的环境中进行复杂的...

    多数据源事物控制

    Atomikos则是一个开源的事务处理监控器（TPM），它实现了JTA（Java Transaction API）和JTS（Java Transaction Service）。JTA是Java中处理分布式事务的标准接口，而JTS则是一个具体的实现。Atomikos可以协调不同...

Magicbox
Global site tag (gtag.js) - Google Analytics