事务的回滚五种方法

最新推荐文章于 2024-09-24 09:41:22 发布
最新推荐文章于 2024-09-24 09:41:22 发布
阅读量1.7w 收藏 14
点赞数
文章标签： bean class spring aop encoding attributes
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pengxiaodong19862/article/details/7041498
版权
 

前段时间对Spring的事务配置做了比较深入的研究，在此之间对Spring的事务配置虽说也配置过，但是一直没有一个清楚的认识。通过这次的学习发觉Spring的事务配置只要把思路理清，还是比较好掌握的。

    总结如下：

    Spring配置文件中关于事务配置总是由三个组成部分，分别是DataSource、TransactionManager和代理机制这三部分，无论哪种配置方式，一般变化的只是代理机制这部分。

    DataSource、TransactionManager这两部分只是会根据数据访问方式有所变化，比如使用Hibernate进行数据访问时，DataSource实际为SessionFactory，TransactionManager的实现为HibernateTransactionManager。

    具体如下图：

根据代理机制的不同，总结了五种Spring事务的配置方式，配置文件如下：

    第一种方式：每个Bean都有一个代理

<?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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

    <bean id="sessionFactory" 
            class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> 
        <property name="configLocation" value="classpath:hibernate.cfg.xml" /> 
        <property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" />
    </bean> 

    <!-- 定义事务管理器（声明式的事务） --> 
    <bean id="transactionManager"
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>
   
    <!-- 配置DAO -->
    <bean id="userDaoTarget" class="com.bluesky.spring.dao.UserDaoImpl">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>
   
    <bean id="userDao" 
        class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"> 
           <!-- 配置事务管理器 --> 
           <property name="transactionManager" ref="transactionManager" />    
        <property name="target" ref="userDaoTarget" /> 
         <property name="proxyInterfaces" value="com.bluesky.spring.dao.GeneratorDao" />
        <!-- 配置事务属性 --> 
        <property name="transactionAttributes"> 
            <props> 
                <prop key="*">PROPAGATION_REQUIRED</prop>
            </props> 
        </property> 
    </bean> 
</beans>

    第二种方式：所有Bean共享一个代理基类

<?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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

    <bean id="sessionFactory" 
            class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> 
        <property name="configLocation" value="classpath:hibernate.cfg.xml" /> 
        <property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" />
    </bean> 

    <!-- 定义事务管理器（声明式的事务） --> 
    <bean id="transactionManager"
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>
   
    <bean id="transactionBase" 
            class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean" 
            lazy-init="true" abstract="true"> 
        <!-- 配置事务管理器 --> 
        <property name="transactionManager" ref="transactionManager" /> 
        <!-- 配置事务属性 --> 
        <property name="transactionAttributes"> 
            <props> 
                <prop key="*">PROPAGATION_REQUIRED</prop> 
            </props> 
        </property> 
    </bean>   
  
    <!-- 配置DAO -->
    <bean id="userDaoTarget" class="com.bluesky.spring.dao.UserDaoImpl">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>
   
    <bean id="userDao" parent="transactionBase" > 
        <property name="target" ref="userDaoTarget" />  
    </bean>
</beans>

 

 

 

第三种方式：使用拦截器

<?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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

    <bean id="sessionFactory" 
            class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> 
        <property name="configLocation" value="classpath:hibernate.cfg.xml" /> 
        <property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" />
    </bean> 

    <!-- 定义事务管理器（声明式的事务） --> 
    <bean id="transactionManager"
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean> 
  
    <bean id="transactionInterceptor" 
        class="org.springframework.transaction.interceptor.TransactionInterceptor"> 
        <property name="transactionManager" ref="transactionManager" /> 
        <!-- 配置事务属性 --> 
        <property name="transactionAttributes"> 
            <props> 
                <prop key="*">PROPAGATION_REQUIRED</prop> 
            </props> 
        </property> 
    </bean>
     
    <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator"> 
        <property name="beanNames"> 
            <list> 
                <value>*Dao</value>
            </list> 
        </property> 
        <property name="interceptorNames"> 
            <list> 
                <value>transactionInterceptor</value> 
            </list> 
        </property> 
    </bean> 
 
    <!-- 配置DAO -->
    <bean id="userDao" class="com.bluesky.spring.dao.UserDaoImpl">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>
</beans>

第四种方式：使用tx标签配置的拦截器

<?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-2.5.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

    <context:annotation-config />
    <context:component-scan base-package="com.bluesky" />

    <bean id="sessionFactory" 
            class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> 
        <property name="configLocation" value="classpath:hibernate.cfg.xml" /> 
        <property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" />
    </bean> 

    <!-- 定义事务管理器（声明式的事务） --> 
    <bean id="transactionManager"
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>

    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="*" propagation="REQUIRED" />
        </tx:attributes>
    </tx:advice>
   
    <aop:config>
        <aop:pointcut id="interceptorPointCuts"
            expression="execution(* com.bluesky.spring.dao.*.*(..))" />
        <aop:advisor advice-ref="txAdvice"
            pointcut-ref="interceptorPointCuts" />       
    </aop:config>     
</beans>

 

第五种方式：全注解

<?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-2.5.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

    <context:annotation-config />
    <context:component-scan base-package="com.bluesky" />

    <tx:annotation-driven transaction-manager="transactionManager"/>

    <bean id="sessionFactory" 
            class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> 
        <property name="configLocation" value="classpath:hibernate.cfg.xml" /> 
        <property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" />
    </bean> 

    <!-- 定义事务管理器（声明式的事务） --> 
    <bean id="transactionManager"
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>
   
</beans>

 

 

package com.bluesky.spring.dao;

import java.util.List;

import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import org.springframework.stereotype.Component;

import com.bluesky.spring.domain.User;

@Transactional
@Component("userDao")
public class UserDaoImpl extends HibernateDaoSupport implements UserDao {

    public List<User> listUsers() {
        return this.getSession().createQuery("from User").list();
    }
   
   
}

 

 

 

 

 

注意的几点：

1、@Transactional只能被应用到public方法上，对于其他非public的方法，如果标记了@Transactional也不会

报错，但方法没有事务功能。

2、默认情况下，一个有事务方法，遇到RuntimeException时会回滚，遇到受检查的异常是不会回滚的。要想所

有异常都回滚，要加上@Transactional(rollbackFor={Exception.class, 其他异常})。

 

Transactional的所有可选属性如下：

属性                      类型                      默认值         说明

propagation               Propagation枚举           REQUIRED       事务传播属性(下有说明)

isolation                 isolation枚举             DEFAULT        事务隔离级别(另有说明)

readOnly                  boolean                   false          是否只读

timeout                   int                       -1             超时(秒)

rollbackFor               Class[]                   {}             需要回滚的异常类

rollbackForClassName      String[]                  {}             需要回滚的异常类名

noRollbackFor             Class[]                   {}             不需要回滚的异常类

noRollbackForClassName    String[]                  {}             不需要回滚的异常类名

 

事务的隔离级别  有如下可选：

可以去看spring的源代码：org.springframework.transaction.annotation.Isolation

DEFAULT                   采用数据库默认隔离级别

READ_UNCOMMITTED

READ_COMMITTED

REPEATABLE__READ

SERIALIZABLE

 

事务的传播属性，有如下可选：

可以去看spring的源代码：org.springframework.transaction.annotation.Propagation

REQUIRED：业务方法需要在一个事务中运行，如果方法运行时，已处在一个事务中，那么就加入该事务，否则自

          己创建一个新的事物，这是spring默认的传播行为。

SUPPORTS：如果业务方法在某个事物范围内被调用，则方法成为该事务的一部分，如果业务方法在事务范围外被

          调用，则方法在没有事务的环境下执行。

MANDATORY：只能在一个已存在事务中执行，业务方法不能发起自己的事物，如果业务方法在没有事务的环境下

           调用，就抛异常。

REQUIRES_NEW：业务方法总是会为自己发起一个新的事务，如果方法已运行在一个事务中，则原有方法被挂起，

              新的事务被创建，直到方法结束，新事务才结束，原先的事务才会恢复执行。

NOT_SUPPORTED：声明方法需要事务，如果方法没有关联到一个事务，容器不会为他开启事务，如果方法在一个

               事务中被调用，该事务会被挂起，在方法调用结束后，原先的事务便会恢复执行。

NEVER：声明方法绝对不能在事务范围内执行，如果方法在某个事务范围内执行，容器就抛异常，只有没关联到

       事务，才正常执行。

NESTED：如果一个活动的事务存在，则运行在一个嵌套的事务中，如果没有活动的事务，则按REQUIRED属性执

        行。它使用了一个单独的事务，这个事务拥有多个可以回滚的保证点，内部事务回滚不会对外部事务造

        成影响，它只对DataSource。

 

火箭
关注
七、回滚机制——事务回滚
流楚丶格念的博客
08-24 956
在 Spring Boot 和 Spring Cloud 中实现事务回滚，可以根据系统的复杂性选择合适的事务管理策略。对于单库事务，使用 Spring 的注解即可实现事务管理和回滚。对于分布式事务，可以选择使用两阶段提交（2PC）、三阶段提交（3PC）、TCC 模式或 Sagas 模式等方法来保证事务的一致性和完整性。
事务回滚哦
m0_65545927的博客
03-24 970
事务回滚
java中手动回滚事物
最新发布
weixin_45650629的博客
09-24 395
1、原因是因为代码中我写了try catch，try catch后异常被catch捕获了，catch后的业务代码还会继续执行，捕获后的异常会在后台的日志中打印，不会把这个异常错误抛给前端了；2、这个时候如果你使用的是事物注解@Transcation，因为你异常被捕获所以它并不会帮你回滚代码了，这时候就需要我们自己在catch中进行手动事物回滚。为什么要手动回滚事物？
事务的回滚
至宝屠夫的博客
01-29 555
事务回滚有两种： 1. throw  new RuntimeException 2.TransactionAspectSupport.currentTransactionStatus().setRollbackOnly(); 下面我来说一下这两个有啥区别。 第一种， 抛出一个异常，这种方法很简单粗暴，但是有一个很隐蔽的问题：如果不小心抛出去得异常又被自己catch住了，就不能进行回
事务回滚的使用
weixin_34194551的博客
12-10 115
//采用事务处理转账失败的情况 @Test publicvoidtestTransaction1()throwsException{ //获得链接对象 Connectionconn=JdbcUtils.getConnection(); PreparedStatementpstmt=null; PreparedStatementpstmt1=nu...
SpringBoot事务注解@Transactional
rogerxue12345的博客
03-04 1171
1. 事务说明 在Spring中，事务有两种实现方式，分别是编程式事务管理和声明式事务管理两种方式。编程式事务管理： 编程式事务管理使用TransactionTemplate或者直接使用底层的PlatformTransactionManager。对于编程式事务管理，spring推荐使用TransactionTemplate。声明式事务管理： 建立在AOP之上的。其本质是对方法前后进行拦截，然后在...
使用SpringBoot注解方式处理事务回滚实现
08-18
在本文中，我们将介绍使用 SpringBoot 注解方式处理事务回滚实现的方法，并通过示例代码进行详细的讲解。本文对于学习 SpringBoot 的开发者或者工作中需要实现事务回滚的朋友们具有非常重要的参考价值。 首先，让...
3种常见的事务回滚
m0_66918076的博客
06-09 3125
3种常见的事务回滚
mongoDB 4.0事务回滚的辛酸历程探究
09-09
事务回滚是事务处理中的关键部分，确保在出现错误或异常时，数据库能够恢复到事务开始之前的状态。 在升级到MongoDB 4.0之后，首先需要注意的是确保环境的兼容性。使用Homebrew升级MongoDB到4.0.0版本，同时更新`...
事务回滚
ssllnn1314的博客
04-26 744
事务提交是提交事务的所有操作：具体来说就是将事务中所有对数据库的更新写回到磁盘上的物理数据库中，事务正常结束； 事务回滚是数据库返回到事务开始的状态：事务在运行过程中发生某种故障，事务不能继续执行，系统将事务中对数据库的所有已完成的更新操作全部撤销，使数据库回滚到事务开始时的状态。 ...
事务的理解
努力和遗憾，哪个更让你痛苦？
03-21 481
事务是恢复和并发控制的基本单位。 事务应该具有4个属性：原子性、一致性、隔离性、持久性。这四个属性通常称为ACID特性。 原子性（atomicity）。一个事务是一个不可分割的工作单位，事务中包括的诸操作要么都做，要么都不做。 一致性（consistency）。事务必须是使数据库从一个一致性状态变到另一个一致性状态。一致性与原子性是密切相关的。 隔离性（isolation）
简单的c#事务回滚实例代码
12-22
在.NET框架中，C#语言提供了对事务处理的强大支持，特别是在数据库操作中，事务回滚是确保数据一致性的重要机制。本实例将详细讲解如何在C#中实现简单的事务回滚功能，以应对在执行多条SQL语句时可能出现的错误。 ...
事务及回滚
qq_34358193的博客
06-14 1463
事务事务的ACID特性，即原子性、一致性、隔离性、持久性。1、原子性：事务必须是原子工作单元，对其进行的数据修改，要么全部执行，要么全不执行。 事务执行的结果必须是使数据库从一个一致性状态变到另一个一致性状态。比如，当数据库只包含成功事务提交的结果时，就说数据库处于一致性状态。如果数据库系统在运行中发生故障，有些事务尚未完成就被迫中断，这些未完成事务对数据库所做的修改有一部分已写入物理数据库，这时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

火箭

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值