jta+spring4+hibernate5/jpa2配置

最新推荐文章于 2024-02-28 07:00:00 发布
最新推荐文章于 2024-02-28 07:00:00 发布
阅读量4.3k 收藏 1
点赞数 1
文章标签： hibernate spring jta
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013855332/article/details/51626972
版权
  • 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:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
                http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-4.2.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.2.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx-4.2.xsd
        ">
    <context:component-scan base-package="com"/>
    <!--<aop:aspectj-autoproxy proxy-target-class="true"/>-->
    <!--配置数据源与数据库连接池 -->
    <bean id="ds1" class="com.atomikos.jdbc.AtomikosDataSourceBean" init-method="init" destroy-method="close">
        <property name="uniqueResourceName" value="ds1"/>
        <property name="xaDataSourceClassName" value="com.mysql.jdbc.jdbc2.optional.MysqlXADataSource"/>
        <property name="xaProperties">
            <props>
                <prop key="user">root</prop>
                <prop key="password">1853</prop>
                <prop key="url">jdbc:mysql://127.0.0.1:3306/world?useUnicode=true&amp;characterEncoding=UTF-8&amp;useFastDateParsing=false&amp;pinGlobalTxToPhysicalConnection=true</prop>
            </props>
        </property>
        <property name="maxPoolSize" value="10"/>
        <property name="minPoolSize" value="1"/>
    </bean>
    <!--配置事务管理器的内部内容-->
    <bean id="userTransactionService"
          class="com.atomikos.icatch.config.UserTransactionServiceImp"
          init-method="init" destroy-method="shutdownForce">
        <constructor-arg>
            <!-- IMPORTANT: specify all Atomikos properties here -->
            <props>
                <prop key="com.atomikos.icatch.service">
                    com.atomikos.icatch.standalone.UserTransactionServiceFactory
                </prop>
            </props>
        </constructor-arg>
    </bean>
    <!--配置一个事务管理器-->
    <bean id="transactionManager" class="com.atomikos.icatch.jta.UserTransactionManager"
          init-method="init" destroy-method="close" depends-on="userTransactionService">
        <property name="forceShutdown">
            <value>false</value>
        </property>
    </bean>
    <!--配置一个用户事务实现-->
    <bean id="userTransaction" class="com.atomikos.icatch.jta.UserTransactionImp">
        <property name="transactionTimeout" value="300" />
    </bean>
    <!--_________________________jpa需要自己重写一个JtaPlatfom______________________________________________-->
    <!--实例化一个EntityManagerFactory-->
    <!--该bean的作用是将spring中配置的tranactionManager,usertransaction注入到AtomikosJtaPlatfom中的一个静态域中,实现spring事务管理器与hibernate的事务管理器一致!!!!-->
    <bean id="ajp" class="com.test.AtomikosJtaPlatfom">
        <property name="tm" ref="transactionManager"/>
        <property name="ut" ref="userTransaction"/>
    </bean>
    <!--强制要求先实例化ajp,这样能够保证hibernate使用了spring初始化后的transactionManager与usertransaction-->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean" depends-on="ajp">
        <property name="packagesToScan" value="com"/>
        <property name="persistenceUnitName" value="PU1"/>
        <property name="jtaDataSource" ref="ds1"/>
        <!-- 方言,鸡肋-->
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                <property name="generateDdl" value="true"/>
                <property name="showSql" value="true"/>
                <property name="database" value="MYSQL"/>
            </bean>
        </property>
        <property name="jpaProperties">
            <props>
                <!--以下属性必须加有hibernate-->
                <prop key="hibernate.show_sql">true</prop>
                <!--必要的-->
                <prop key="hibernate.transaction.coordinator_class">jta</prop>
                <prop key="hibernate.format_sql">true</prop>
                <prop key="hibernate.hbm2ddl.auto">update</prop>
                <!--由于spring没有为jpa提供jta管理注入,所以需要手工配置一个JtaPlatfom-->
                <prop key="hibernate.transaction.jta.platform">com.test.AtomikosJtaPlatfom</prop>
                <!--自动为所有关键字的类名/实例域添加``-->
                <prop key="hibernate.auto_quote_keyword">true</prop>
            </props>
        </property>
    </bean>
    <!--____________________________sessionfactory不需要配置jtaPlatform,因为spring提供了支持___________________________________________-->
    <!--实例化一个SessionFactory,getBean()将返回一个SessionFactory实例-->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
        <property name="packagesToScan" value="com"/>
        <property name="annotatedPackages" value="com"/>
        <property name="dataSource" ref="ds1"/>
        <!--spring自动配置jtaplatfom,但是jpa需要自己配置-->
        <property name="jtaTransactionManager" ref="transactionManager"/>
        <property name="hibernateProperties">
            <props>
                <!--以下属性必须加有hibernate-->
                <prop key="hibernate.show_sql">true</prop>
                <!--必要的-->
                <prop key="hibernate.transaction.coordinator_class">jta</prop>
                <prop key="hibernate.format_sql">true</prop>
                <prop key="hibernate.hbm2ddl.auto">update</prop>
                <!--自动为所有关键字的类名/实例域添加``-->
                <prop key="hibernate.auto_quote_keyword">true</prop>
            </props>
        </property>
    </bean>
    <!--_______________________________________________________________________-->

    <bean id="jtaTransactionManager" class="org.springframework.transaction.jta.JtaTransactionManager">
        <property name="rollbackOnCommitFailure" value="true"/>
        <property name="transactionManager" ref="transactionManager"/>
        <property name="userTransaction" ref="userTransaction"/>
    </bean>
    <!--编程式事务模板-->
    <bean id="tansactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
        <property name="transactionManager" ref="jtaTransactionManager"/>
    </bean>
    <!--非注解的声明式事务-->
    <!--<tx:advice id="transactionInterceptor" transaction-manager="jtaTransactionManager">-->
        <!--<tx:attributes>-->
            <!--<tx:method name="doPost" propagation="REQUIRED"/>-->
            <!--<tx:method name="*" propagation="SUPPORTS"/>-->
        <!--</tx:attributes>-->
    <!--</tx:advice>-->
    <!--<aop:config>-->
        <!--<aop:advisor advice-ref="transactionInterceptor" pointcut="execution(* *..S.*(..))"/>-->
    <!--</aop:config>-->
    <!--注解的声明式事务，使用@Transactionals注解bean，可在类上或方法上使用-->
    <!--<tx:annotation-driven transaction-manager="jtaTransactionManager"/>-->
    <!--<context:component-scan base-package="com">-->
        <!--<context:include-filter type="assignable" expression="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor"/>-->
    <!--</context:component-scan>-->
</beans>
  • AtomikolsJtaPlatfom,必须先由spring注入hibernate才能正常工作.
package com.test;

import org.hibernate.engine.transaction.jta.platform.internal.AbstractJtaPlatform;
import org.hibernate.engine.transaction.jta.platform.spi.JtaPlatform;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;

import javax.transaction.*;

/**
 * @author doggy
 *         Created on 16-5-15.
 */
public class AtomikosJtaPlatfom extends AbstractJtaPlatform {
    private static UserTransaction ut;
    private static TransactionManager tm;
    @Override
    protected TransactionManager locateTransactionManager() {
        return tm;
    }

    @Override
    protected UserTransaction locateUserTransaction() {
        return ut;
    }

    public UserTransaction getUt() {
        return ut;
    }

    public void setUt(UserTransaction ut) {
        AtomikosJtaPlatfom.ut = ut;
    }

    public TransactionManager getTm() {
        return tm;
    }

    public void setTm(TransactionManager tm) {
        AtomikosJtaPlatfom.tm = tm;
    }
}
  • 样例
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        try(PrintWriter writer = resp.getWriter()) {
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
            SessionFactory sessionFactoryBean = (SessionFactory) applicationContext.getBean("sessionFactory");
            TransactionTemplate template = (TransactionTemplate)applicationContext.getBean("tansactionTemplate");
            template.execute(new TransactionCallback<Object>() {
                @Override
                public Object doInTransaction(TransactionStatus transactionStatus) {
                    try{
                        Session session = sessionFactoryBean.getCurrentSession();
                        Fuck f = new Fuck();
                        session.save(f);
                    }catch(RuntimeException re){
                        re.printStackTrace();
                    }
                    //回滚事务
                    transactionStatus.setRollbackOnly();
                    return null;
                }
            });
            writer.println("love you");
            writer.close();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
  • 依赖
<?xml version="1.0" encoding="UTF-8"?>
<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>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.3.2</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
        <resources>
            <resource>
                <directory>src</directory>
                <includes>
                    <include>**/*.xml</include>
                    <include>**/*.xls*</include>
                    <include>**/*.properties</include>
                </includes>
            </resource>
        </resources>
    </build>

    <groupId>fish</groupId>
    <artifactId>fish</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!-- spring -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.2.5.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>4.2.5.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>4.2.5.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>4.2.5.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>4.2.5.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>4.2.5.RELEASE</version>
        </dependency>

        <!-- struts2 -->
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-core</artifactId>
            <version>2.3.20</version>
        </dependency>

        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-spring-plugin</artifactId>
            <version>2.3.20</version>
        </dependency>

        <!-- hibernate -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>5.1.0.Final</version>
        </dependency>
        <!-- http://mvnrepository.com/artifact/org.hibernate/hibernate-entitymanager -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>5.1.0.Final</version>
        </dependency>


        <!-- jta and mysql -->
        <dependency>
            <groupId>com.atomikos</groupId>
            <artifactId>transactions-jdbc</artifactId>
            <version>4.0.1</version>
        </dependency>
        <!-- http://mvnrepository.com/artifact/com.atomikos/transactions-hibernate3 -->
        <dependency>
            <groupId>com.atomikos</groupId>
            <artifactId>transactions-hibernate3</artifactId>
            <version>4.0.3</version>
        </dependency>


        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.38</version>
        </dependency>

        <!-- for json -->
        <dependency>
            <groupId>com.thoughtworks.xstream</groupId>
            <artifactId>xstream</artifactId>
            <version>1.4.2</version>
        </dependency>
        <dependency>
            <groupId>org.codehaus.jettison</groupId>
            <artifactId>jettison</artifactId>
            <version>1.3.7</version>
        </dependency>

        <dependency>
            <groupId>net.sf.json-lib</groupId>
            <artifactId>json-lib</artifactId>
            <version>2.4</version>
        </dependency>

        <!-- joda -->
        <dependency>
            <groupId>joda-time</groupId>
            <artifactId>joda-time</artifactId>
            <version>2.9.3</version>
        </dependency>

        <dependency>
            <groupId>org.apache.tomcat</groupId>
            <artifactId>tomcat-catalina</artifactId>
            <version>8.0.33</version>
        </dependency>

        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-frontend-jaxws</artifactId>
            <version>3.1.6</version>
        </dependency>

    </dependencies>
</project>
doggy1853
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
DWR3.0+ hibernate4.1 + spring3.1 基于JPA JTA
10-11
DWR3.0+ hibernate4.1 + spring3.1 基于JPA JTA技术，在glassfish3.1.2和postgresql9上测试通过。参考了网上资料进行整理。
Spring boot+Atomikos+JTA+Hibernate+mybatis+MySQL实现分布式事务+多数据源
10-08
springboot+Atomikos+jpa+mysql的JTA分布式事务实现,本案例涉及到2个数据库，预期结果，在同一个事务中，两个库的状态一致
Hibernate 基本操作、懒加载以及缓存
BASK2311的博客
05-11 422
本篇文章主要讲了基本的 CRUD 操作，都是通过 Session 去操作的，根据一个持久化类的类型以及一个唯一标识进行相关操作，然后讲了 Hibernate 中的对象的状态，有 4 种，分别是瞬时、持久、游离、删除。接着说了 Hibernate 的懒加载，有利于降低数据库的开销，当然缓存也是，除了加快我们的访问速度，也降低了直接访问数据库的开销，缓存就两种，一级和二级，一级默认是开启的，二级需要引入相关的依赖项，然后进行配置，开启二级缓存，配置缓存策略。
已解决org.springframework.transaction.UnexpectedRollbackException意外的回滚异常的正确解决方法，亲测有效！！！
最新发布
小明的Java问道之路
02-28 1738
已解决org.springframework.transaction.UnexpectedRollbackException意外的回滚异常的正确解决方法，亲测有效！！！
【java】hibernate利用Atomikos实现多数据源事务管理
mudarn的博客
11-25 158
1、引入jar包 <!--多数据源--> <dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version>1.1.11</version> </dep...
org.springframework.transaction.UnexpectedRollbackException: JTA transaction already rolled back (pr
.
12-09 3379
org.springframework.transaction.UnexpectedRollbackException: JTA transaction already rolled back (probably due to a timeout) 错误原因默认的Spring 默认的事务是 tomeout 是 -1 原因是 这里使用Spring 默认事务 java int timeout() d...
Spring事务报错： org.springframework.transaction.UnexpectedRollbackException
qq_34041723的博客
03-16 3429
由于ServiceA的传播属性也为PROPAGATION_REQUIRED，所以ServiceA会创建一个事务，然后ServiceB与ServiceA使用同一个事务，ServiceB出现异常后，将当前事务标志位回滚，由于在ServiceA中做了trycatch处理，程序没有终止而是继续往下走，当事务commit时，check状态，发现，需要事务回滚，所以才会出现不可预知的事务异常:因为事务被标志位回滚，所以事务回滚。异常信息：支持当前事务，如果不存在则抛出异常。事务被回滚，因为它被标记为仅回滚。
HIbernate配置JTA的platform
hapinwater的博客
02-20 1205
[code="java"] org.hibernate.ejb.HibernatePersistence jdbc/database com.*.User property name="hibernate.transact...
wicket6.0 + hibernate4.1 + spring3.1 基于JPA的实例程序。
10-11
wicket6.0 + hibernate4.1 + spring3.1 基于JPA的实例程序。采用JTA事务管理。在glassfish3.1.2和postgresql9测试通过。
10分钟解决Hibernate的事务管理,Hibernate当中要设置事务的隔离级别
12-14
一、事务 1、什么是事务： 事务：事物指的是逻辑上的一组操作，组成这一组操作的逻辑单元要么全成功，要么全失败 2、事务的特性： （1）原子性：代表事务不可分割。 （2）一致性：代表事务执行的前后，数据的完整性要保证一直。 （3）隔离性：代表的是一个事务执行的过程当中，不应该受到其他事务的干扰。 （4）持久性：代表一个事务执行完成后数据就持久到数据库当中（提交或回滚）。 3、如果我们不考虑事务的隔离性，就会引发一些安全性的问题 （一）读的问题 （1）脏读：一个事务读到另外一个事务未提交的数据 （2）不可重复读：一个事务读到了另一个事务已经提交的update的数据，导致在前一个事务多次查询结果不一
spring mvc+hibernate实现事务管理（配置文件版）
08-29
spring mvc hibernate整合，采用MyEclipse自动生成包和配置文件，jar包可能有多余，但是不影响整体效果。服务器tomcat。数据库mysql。
Spring4集成JPA和MyBatis3简单例子
05-18
Spring4集成JPA和MyBatis3简单例子
基于maven集成spring5 hibernate5 spring-data-jpa2 H2的简单实例
04-16
网上找不到这样的例子，只好我自已整理一份了。 该demo是基于maven集成spring5、hibernate5、spring-data-jpa2、H2的可以运行的最基本的main例子。 希望能对大家有帮助。
Hibernate4实战 之第五部分：Hibernate的事务和并发
03-21
Hibernate4实战 之第五部分：Hibernate的事务和并发
Spring3.2_Hibernate4.2_JPA2全注解实例
05-11
Spring3.2 Hibernate4.2 JPA2全注解实例.采用JTA事务管理，配置ehcache为二级缓存，在glassfish3.2.2和postgresql9测试通过。参考网上的资料整理。
第二部分spring+hibernate+jta 分布式事务Demo
03-01
Atomikos jta 的jar包 博文链接：https://momoko8443.iteye.com/blog/190994
完美解决org.springframework.transaction.UnexpectedRollbackException
热门推荐
05-14 6万+
该异常通常在以下情况下抛出： 如果一个方法被标记为 @Transactional，并且发生了未被捕获的 RuntimeException 或其他不受检查的异常，事务会自动回滚。如果不希望方法回滚，可以在方法上使用 @Transactional(noRollbackFor = Exception.class) 注解来指定不回滚的异常。 如果在事务方法中手动调用了 setRollbackOnly() 方法来标记事务为回滚状态，那么在事务结束时就会抛出 UnexpectedRollbackException
hibernate+sqlserver整合Atomikos
07-13
在Hibernate和SQL Server上使用Atomikos进行事务管理的整合可以按照以下步骤进行： 1. 添加Atomikos和SQL Server的相关依赖项到你的项目中。你可以在Maven或Gradle中添加以下依赖项： ```xml <!-- Atomikos --> <dependency> <groupId>com.atomikos</groupId> <artifactId>atomikos-transactions-jta</artifactId> <version>4.0.6</version> </dependency> <dependency> <groupId>com.atomikos</groupId> <artifactId>atomikos-transactions-jdbc</artifactId> <version>4.0.6</version> </dependency> <!-- SQL Server --> <dependency> <groupId>com.microsoft.sqlserver</groupId> <artifactId>mssql-jdbc</artifactId> <version>8.2.2.jre8</version> </dependency> ``` 2. 配置Atomikos的事务管理器。在Spring Boot中，可以使用`JtaTransactionManager`来配置Atomikos。 ```java @Configuration public class TransactionConfig { @Bean public UserTransactionManager userTransactionManager() throws SystemException { UserTransactionManager userTransactionManager = new UserTransactionManager(); userTransactionManager.setForceShutdown(true); return userTransactionManager; } @Bean(initMethod = "init", destroyMethod = "close") public UserTransactionImp userTransaction() throws SystemException { UserTransactionImp userTransactionImp = new UserTransactionImp(); userTransactionImp.setTransactionTimeout(300); return userTransactionImp; } @Bean public JtaTransactionManager transactionManager(UserTransactionManager userTransactionManager, UserTransactionImp userTransaction) { JtaTransactionManager transactionManager = new JtaTransactionManager(); transactionManager.setUserTransaction(userTransaction); transactionManager.setTransactionManager(userTransactionManager); return transactionManager; } } ``` 3. 配置SQL Server的数据源。可以使用Spring Boot的自动配置来配置SQL Server的数据源。 ```properties spring.datasource.url=jdbc:sqlserver://localhost:1433;databaseName=mydatabase spring.datasource.username=your-username spring.datasource.password=your-password spring.datasource.driver-class-name=com.microsoft.sqlserver.jdbc.SQLServerDriver spring.jpa.hibernate.ddl-auto=update ``` 4. 使用Hibernate进行数据库访问。在你的实体类上使用Hibernate的注解来映射数据库表。 ```java @Entity @Table(name = "your_table") public class YourEntity { // Entity fields and annotations } ``` 5. 在需要进行事务管理的方法或类上使用`@Transactional`注解。这将确保方法内的数据库操作在Atomikos管理的事务中执行。 ```java @Service @Transactional public class YourService { // Service methods } ``` 通过按照以上步骤配置Atomikos和SQL Server的整合，你可以实现对Hibernate和SQL Server的分布式事务管理。Atomikos将协调和管理涉及多个数据库的事务，确保事务的一致性和原子性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值