hibernate实现JTA事物--代码

最新推荐文章于 2022-10-11 14:54:52 发布
最新推荐文章于 2022-10-11 14:54:52 发布
阅读量413 收藏
点赞数
分类专栏： hibernate 文章标签： java 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/action5362603/article/details/84684495
版权 
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();
		}
	}
}

 <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"> <modelVersion>4.0.0</modelVersion> <groupId>com.ajita</groupId> <artifactId>SimpleDemo</artifactId> <version>0.1</version> <repositories> <repository> <id>maven.apache</id> <name>maven.apache</name> <url>http://repo.maven.apache.org/</url> </repository> <repository> <id>maven</id> <name>maven</name> <url>http://repo1.maven.org/maven2/</url> </repository> </repositories> <properties> <spring.version>3.1.0.RELEASE</spring.version> <hibernate.version>4.1.0.Final</hibernate.version> <atomikos.version>3.8.0</atomikos.version> </properties> <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-tx</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-orm</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-entitymanager</artifactId> <version>${hibernate.version}</version> <exclusions> <exclusion> <groupId>cglib</groupId> <artifactId>cglib</artifactId> </exclusion> <exclusion> <groupId>dom4j</groupId> <artifactId>dom4j</artifactId> </exclusion> </exclusions> </dependency> <dependency> <groupId>com.atomikos</groupId> <artifactId>transactions-jta</artifactId> <version>${atomikos.version}</version> </dependency> <dependency> <groupId>com.atomikos</groupId> <artifactId>transactions-jdbc</artifactId> <version>${atomikos.version}</version> </dependency> <dependency> <groupId>com.atomikos</groupId> <artifactId>transactions-hibernate3</artifactId> <version>${atomikos.version}</version> <exclusions> <exclusion> <artifactId>hibernate</artifactId> <groupId>org.hibernate</groupId> </exclusion> </exclusions> </dependency> <dependency> <groupId>dom4j</groupId> <artifactId>dom4j</artifactId> <version>1.6.1</version> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.25</version> </dependency> <dependency> <groupId>net.sourceforge.jtds</groupId> <artifactId>jtds</artifactId> <version>1.2.6</version> </dependency> <dependency> <groupId>cglib</groupId> <artifactId>cglib</artifactId> <version>2.2.2</version> </dependency> </dependencies> <build> <finalName>SimpleDemo</finalName> </build> </project>

 

<?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: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">myoa</prop>
				<prop key="serverName">127.0.0.1</prop>
				<prop key="port">3306</prop>
				<prop key="user">root</prop>
				<prop key="password">system</prop>
				<prop key="url">jdbc:mysql://127.0.0.1:3306/myoa</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>com.mysql.jdbc.jdbc2.optional.MysqlXADataSource</value>
		</property>
		<property name="xaProperties">
			<props>
				<prop key="databaseName">myoa2</prop>
				<prop key="serverName">127.0.0.1</prop>
				<prop key="port">3306</prop>
				<prop key="user">root</prop>
				<prop key="password">system</prop>
				<prop key="url">jdbc:mysql://127.0.0.1:3306/myoa2</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>

 

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;
	}
}

 

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;
	}
}

 

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;
	}
}

 

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);
		}
	}

}

 

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);
		}
	}

}

 

 

action5362603
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java中的Hibernate是什么？如何使用Hibernate
2301_77769537的博客
05-09 2077
总之，Transaction是Hibernate架构中非常重要的组件，它确保了Java应用程序与数据库之间的顺畅通信，并提供了许多其他有用的功能。总之，Session是Hibernate中非常重要的组件，它为开发人员提供了一种简单而强大的方式来管理Java应用程序与关系数据库之间的交互，并使得进行CRUD操作和数据检索变得更加容易和高效。总之，实体类应该是与Hibernate框架兼容的Java类，它应该定义数据库表中的列，并提供用于访问和操作这些列的方法。实体类应该包含与数据库表中的列对应的属性。
hibernate PO对象操作
bruobuqi的博客
01-04 326
1.1.1 save & persist l save方法：瞬时态 转换 持久态 ,会初始化OID 1.执行save方法，立即触发insert语句，从数据库获得主键的值（OID值） 2.执行save方法前，设置OID将忽略。 3.如果执行查询，session缓存移除了，在执行save方法，将执行insert // save方法,如果保存的对象在保存之前设置了ID.那么该ID也被认为是
spring 结合druid和hibernate使用jta配置分布式事务
10-31
atomikos实现多数据源支持分布式事务管理（spring、tomcat、JTA） 结合spring 和durid进行配置，
Hibernate——JTA
半壁灯的博客
06-29 443
上一篇提到的配置文件中的 thread//当前的session的运行环境 有四种取值jta、thread、managed、custom.Class 常用thread和jta 我们一般将事物分为两种 1.connection事物，依赖数据库本身，只针对一个数据库 2.jta事物，分布式，不止一个数据库 假如要向两个数据库BD1和DB2中分别执行两个操作，一个操作
理解JDBC/JPA/Mybatis/Hibernate
__一叶__的博客
05-11 907
JPA 全称Java Persistence API，为POJO提供持久化标准规范，可以通过注解或者XML描述【对象-关系】之间的映射关系，并将实体对象持久化到数据库中。 JPA是一套ORM规范，Hibernate实现了JPA规范！ Spring Data JPA 可以理解为 JPA 规范的再次封装抽象，底层还是使用了 Hibernate 的 JPA 技术实现。 JDBC和JPA的区别 不同标准：jdbc是数据库的统一接口标准；jpa是orm框架的统一接口标准。 用法区别：jdbc更注...
JPA详解
热门推荐
程序员小刘
10-11 3万+
JPA 的简介 Java Persistence API（Java 持久层 API）：用于对象持久化的 API 作用：使得应用程序以统一的方式访问持久层 JPA 与 Hibernate的什么关系： ​ 1）JPA 是 一个标准的接口 ​ 2 Hibernate 是 JPA 的一个实现 : Hibernate是如何实现与JPA的关系的？ ​ 通过hibernate-annotat...
transactions-jta-5.0.9.jar
最新发布
04-20
jta.jar 各个版本，免费下载 transactions-jta.jar 各个版本，免费下载 ow2-jta-1.1-spec.jar 各个版本，免费下载 JTA规范，当 Hibernate 使用 JTA 的时候需要，不过 App Server 都会带上
transactions-jta-4.0.3.jar
04-20
jta.jar 各个版本，免费下载 transactions-jta.jar 各个版本，免费下载 ow2-jta-1.1-spec.jar 各个版本，免费下载 JTA规范，当 Hibernate 使用 JTA 的时候需要，不过 App Server 都会带上
transactions-jta-4.0.6.jar
04-20
jta.jar 各个版本，免费下载 transactions-jta.jar 各个版本，免费下载 ow2-jta-1.1-spec.jar 各个版本，免费下载 JTA规范，当 Hibernate 使用 JTA 的时候需要，不过 App Server 都会带上
transactions-jta-5.0.6.jar
04-20
jta.jar 各个版本，免费下载 transactions-jta.jar 各个版本，免费下载 ow2-jta-1.1-spec.jar 各个版本，免费下载 JTA规范，当 Hibernate 使用 JTA 的时候需要，不过 App Server 都会带上
第二部分spring+hibernate+jta 分布式事务Demo
03-06
Atomikos jta 的jar包 博文链接：https://momoko8443.iteye.com/blog/190994
transactions-jta-3.6.4.jar
04-20
jta.jar 各个版本，免费下载 transactions-jta.jar 各个版本，免费下载 ow2-jta-1.1-spec.jar 各个版本，免费下载 JTA规范，当 Hibernate 使用 JTA 的时候需要，不过 App Server 都会带上
【HIbernate学习】HIbernate架构（二）
wz1989love的专栏
11-26 118
Hibernate 使用不同的现存 Java API，比如 JDBC，Java 事务 API（JTA），以及 Java 命名和目录界面（JNDI）。JDBC 提供了一个基本的抽象级别的通用关系数据库的功能， Hibernate 支持几乎所有带有 JDBC 驱动的数据库。JNDI 和 JTA 允许 Hibernate 与 J2EE 应用程序服务器相集成。下面的部分简要地描述了在 Hibernate ...
SpringBoot之JPA框架下如何使用JTA——分布式事务解决方案
wangzhezhilu001的专栏
10-11 929
本篇博客的精髓，在于实现Springboot框架下的分布式事务。
在EJB 中 配置Hibernate支持JTA
半山俗人
03-01 293
Finally,  搞清楚了些Hibernate 的对JTA 的支持。    有几个非常重要的property 需要配置 &lt;prop key="hibernate.current_session_context_class"&gt; jta &lt;/prop&gt;   &lt;prop   key="hibernate.transaction.manager_lookup...
(10) ejb学习: Jpa的JTA事务和RESOURCE_LOCAL事务
jianfpeng241241的专栏
07-19 2510
一 事务的基本概念    1 原子性 : 所有操作要么都成功,要么都失败    2 一致性 : 事务不能违反完整性约束(比如虽然事务还未提交,但仍然需要遵守约束规则,这些规则是事务提交之前而                     非事务提交之后才能生效)    3 隔离性 : 一个事务的效果,不能影响其它同时执行的事务    4 持久性 : 一旦事务成功完成,则数据必须保证已经正确的持
spring+hibernate+jta 分布式事务Demo
a22587的专栏
01-11 813
转载“：http://momoko8443.iteye.com/blog/190994 0、设计分布式数据库，修改第一部分的例子。先将db1中的user1表中的记录清除，把user2表drop掉，然后create一个新的database db2来模拟分布式数据库，在db2中新建一张表user2，结构和user1一致。接下来的操作就是同时对2个数据库的2张表进行操作了。 1、DA
jpa的persistence.xml配置文件详情
管子（zero）的杂乱空间
09-07 87
jpa的persistence.xml配置文件详情 Xml代码 &lt;?xmlversion="1.0"encoding="UTF-8"?&gt; &lt;persistenceversion="1.0" xmlns:persistence="http://java.sun.com/xml/ns/persistence" xmlns:xsi="htt
EJB之JPA(EntityManager)
weixin_30664051的博客
09-16 183
基本概念 EntityManager称为实体管理器，它由EntityManagerFactory所创建。EntityManagerFactory，作为EntityManager的工厂，包含有当前O-R映射的元数据信息，每个EntityManagerFactory，可称为一个持久化单元（PersistenceUnit），每个持久化单元可认为是一个数据源的映射（所谓数据源，可理解为一个数...
HIbernate配置JTA的platform
05-30
要在Hibernate中配置JTA的platform，需要进行以下步骤： 1. 添加Hibernate的JTA依赖库，例如：hibernate-jpa-2.1-api.jar、hibernate-entitymanager.jar等。 2. 在persistence.xml文件中，配置JTA的数据源和事务管理器。例如： ``` <persistence-unit name="examplePU" transaction-type="JTA"> <jta-data-source>java:jboss/datasources/exampleDS</jta-data-source> <properties> <property name="hibernate.transaction.jta.platform" value="org.hibernate.service.jta.platform.internal.JBossAppServerJtaPlatform" /> </properties> </persistence-unit> ``` 3. 在代码中获取EntityManagerFactory时，需要使用JPA的JtaPlatform类。例如： ``` JtaPlatform jtaPlatform = new JBossAppServerJtaPlatform(); entityManagerFactory = Persistence.createEntityManagerFactory("examplePU", Collections.singletonMap("hibernate.transaction.jta.platform", jtaPlatform)); ``` 这样，就可以在Hibernate中配置JTA的platform了。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值