Spring中@Transactional事务回滚（含实例详细讲解，附源码）

最新推荐文章于 2024-07-08 11:40:41 发布
最新推荐文章于 2024-07-08 11:40:41 发布
阅读量5.8k 收藏 1
点赞数

Spring中@Transactional事务回滚（含实例详细讲解，附源码）

2016/05/02 | 分类： 基础技术 | 2 条评论 | 标签： SPRING, 事务

分享到： 13
原文出处：  小宝鸽

一、使用场景举例

在了解@Transactional怎么用之前我们必须要先知道@Transactional有什么用。下面举个栗子：比如一个部门里面有很多成员，这两者分别保存在部门表和成员表里面，在删除某个部门的时候，假设我们默认删除对应的成员。但是在执行的时候可能会出现这种情况，我们先删除部门，再删除成员，但是部门删除成功了，删除成员的时候出异常了。这时候我们希望如果成员删除失败了，之前删除的部门也取消删除。这种场景就可以使用@Transactional事物回滚。

二、checked异常和unchecked异常

这里之所以让大家清楚checked异常和unchecked异常概念，是因为：
Spring使用声明式事务处理，默认情况下，如果被注解的数据库操作方法中发生了unchecked异常，所有的数据库操作将rollback；如果发生的异常是checked异常，默认情况下数据库操作还是会提交的。

checked异常：
表示无效，不是程序中可以预测的。比如无效的用户输入，文件不存在，网络或者数据库链接错误。这些都是外在的原因，都不是程序内部可以控制的。
必须在代码中显式地处理。比如try-catch块处理，或者给所在的方法加上throws说明，将异常抛到调用栈的上一层。
继承自java.lang.Exception（java.lang.RuntimeException除外）。

unchecked异常：
表示错误，程序的逻辑错误。是RuntimeException的子类，比如IllegalArgumentException, NullPointerException和IllegalStateException。
不需要在代码中显式地捕获unchecked异常做处理。
继承自java.lang.RuntimeException（而java.lang.RuntimeException继承自java.lang.Exception）。

看下面的异常结构图或许层次感更加深些：

这里写图片描述

三、@Transactional的使用实例

本实例采用的是Eclipse+maven，maven只是作为jar管理，即便不了解的maven的猿友也可以读懂。

3.1、spring的配置文件

里面必须先配置tx名字空间如下：

这里写图片描述

为了使用基于@Transactional的事务管理，需要在Spring中进行如下的配置：

1
2
3
4
5
<bean id= "appTransactionManager" class = "org.springframework.jdbc.datasource.DataSourceTransactionManager" >
       <property name= "dataSource" ref= "dataSource" />
     </bean>
 
     <tx:annotation-driven proxy-target- class = "false" transaction-manager= "appTransactionManager" />

博主的整个spring配置文件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
<?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:tx= "http://www.springframework.org/schema/tx"
     xmlns:aop= "http://www.springframework.org/schema/aop"
     xsi:schemaLocation=" 
 
http: //www.springframework.org/schema/tx
 
 
http: //www.springframework.org/schema/tx/spring-tx-2.5.xsd
 
 
http: //www.springframework.org/schema/beans
 
 
http: //www.springframework.org/schema/beans/spring-beans-3.0.xsd
 
 
http: //www.springframework.org/schema/aop
 
 
http: //www.springframework.org/schema/aop/spring-aop-3.0.xsd
 
 
http: //www.springframework.org/schema/context
 
 
http: //www.springframework.org/schema/context/spring-context-3.0.xsd">
 
      <!-- 引入jdbc配置文件 --> 
      <bean id= "propertyConfigurer" class = "org.springframework.beans.factory.config.PropertyPlaceholderConfigurer" >
         <property name= "locations" >
             <list>
                <value>classpath:properties/*.properties</value>
                 <!--要是有多个配置文件，只需在这里继续添加即可 -->
             </list>
         </property>
     </bean>
 
     <!-- 配置数据源 -->
     <bean id= "dataSource"
         class = "org.springframework.jdbc.datasource.DriverManagerDataSource" >
         <!-- 不使用properties来配置 -->
         <!-- <property name= "driverClassName" value= "com.mysql.jdbc.Driver" />
             <property name= "url" value= "jdbc:mysql://localhost:3306/learning" />
             <property name= "username" value= "root" />
             <property name= "password" value= "christmas258@" /> -->
        <!-- 使用properties来配置 -->
         <property name= "driverClassName" >
             <value>${jdbc_driverClassName}</value>
         </property>
         <property name= "url" >
             <value>${jdbc_url}</value>
         </property>
         <property name= "username" >
             <value>${jdbc_username}</value>
         </property>
         <property name= "password" >
             <value>${jdbc_password}</value>
         </property>
     </bean>
 
     <bean id= "appTransactionManager" class = "org.springframework.jdbc.datasource.DataSourceTransactionManager" >
       <property name= "dataSource" ref= "dataSource" />
     </bean>
 
     <tx:annotation-driven proxy-target- class = "false" transaction-manager= "appTransactionManager" />
 
     <!-- 自动扫描了所有的XxxxMapper.xml对应的mapper接口文件，这样就不用一个一个手动配置Mpper的映射了，只要Mapper接口类和Mapper映射文件对应起来就可以了。 -->
     <bean class = "org.mybatis.spring.mapper.MapperScannerConfigurer" >
         <property name= "basePackage"
             value= "com.luo.dao" />
     </bean>
 
     <!-- 配置Mybatis的文件 ，mapperLocations配置**Mapper.xml文件位置，configLocation配置mybatis-config文件位置-->
     <bean id= "sqlSessionFactory" class = "org.mybatis.spring.SqlSessionFactoryBean" >
         <property name= "dataSource" ref= "dataSource" />
         <property name= "mapperLocations" value= "classpath:mapper/*.xml" /> 
         <property name= "configLocation" value= "classpath:mybatis/mybatis-config.xml" />
         <!-- <property name= "typeAliasesPackage" value= "com.tiantian.ckeditor.model"
             /> -->
     </bean>
 
     <!-- 自动扫描注解的bean -->
     <context:component-scan base- package = "com.luo.service" />
 
</beans>

3.2、使用@Transactional，在添加用户实现类方法加上注解

1
2
3
4
5
6
7
8
@Transactional (propagation=Propagation.REQUIRED)
public void addUser(User user) {
     userDao.addUser(user);
     String string  = null ;
     if (string.equals( "" )) {
         int i = 0 ;
     }
}

上面的方法我故意让其出现空指针异常，会事物回滚

3.3、运行单元测试类

1
2
3
4
5
6
7
@Test 
public void addUserTest(){ 
     User user = new User();
     user.setUserName( "luoguohui1" );
     user.setUserPassword( "luoguohui1" );
     userService.addUser(user);
}

发现无法插入进去，但是如果把@Transactional去掉，即代码如下，虽然出现异常，但是数据库中还是有添加对应数据的：

这里写图片描述

3.4、源码下载

本文的工程是在mybatis入门（含实例教程和源码）的基础上修改的，该文包含了数据库脚本及工程搭建的详细流程。

本文最终源码下载：

http://download.csdn.net/detail/u013142781/9381184

四、Spring中的@Transactional必须要了解的概念

Spring中的@Transactional基于动态代理的机制，提供了一种透明的事务管理机制，方便快捷解决在开发中碰到的问题。

一般使用是通过如下代码对方法或接口或类注释：

1
@Transactional (propagation=Propagation.NOT_SUPPORTED)

Propagation支持7种不同的传播机制：

REQUIRED：如果存在一个事务，则支持当前事务。如果没有事务则开启一个新的事务。

SUPPORTS： 如果存在一个事务，支持当前事务。如果没有事务，则非事务的执行。但是对于事务同步的事务管理器，PROPAGATION_SUPPORTS与不使用事务有少许不同。

NOT_SUPPORTED：总是非事务地执行，并挂起任何存在的事务。

REQUIRESNEW：总是开启一个新的事务。如果一个事务已经存在，则将这个存在的事务挂起。

MANDATORY：如果已经存在一个事务，支持当前事务。如果没有一个活动的事务，则抛出异常。

NEVER：总是非事务地执行，如果存在一个活动事务，则抛出异常

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

下面是一些需要注意的事项，必须必须必须要看，不然遇到各种坑别说博主没有提醒你哦：

下面是一些需要注意的事项，必须必须必须要看，不然遇到各种坑别说博主没有提醒你哦：

下面是一些需要注意的事项，必须必须必须要看，不然遇到各种坑别说博主没有提醒你哦：

  1. 在需要事务管理的地方加@Transactional 注解。@Transactional 注解可以被应用于接口定义和接口方法、类定义和类的 public 方法上。
  2. @Transactional 注解只能应用到 public 可见度的方法上。 如果你在 protected、private 或者 package-visible 的方法上使用 @Transactional 注解，它也不会报错， 但是这个被注解的方法将不会展示已配置的事务设置。
  3. 注意仅仅 @Transactional 注解的出现不足于开启事务行为，它仅仅 是一种元数据。必须在配置文件中使用配置元素，才真正开启了事务行为。
  4. 通过 元素的 “proxy-target-class” 属性值来控制是基于接口的还是基于类的代理被创建。如果 “proxy-target-class” 属值被设置为 “true”，那么基于类的代理将起作用（这时需要CGLIB库cglib.jar在CLASSPATH中）。如果 “proxy-target-class” 属值被设置为 “false” 或者这个属性被省略，那么标准的JDK基于接口的代理将起作用。
  5. Spring团队建议在具体的类（或类的方法）上使用 @Transactional 注解，而不要使用在类所要实现的任何接口上。在接口上使用 @Transactional 注解，只能当你设置了基于接口的代理时它才生效。因为注解是 不能继承 的，这就意味着如果正在使用基于类的代理时，那么事务的设置将不能被基于类的代理所识别，而且对象也将不会被事务代理所包装。
  6. @Transactional 的事务开启 ，或者是基于接口的 或者是基于类的代理被创建。所以在同一个类中一个方法调用另一个方法有事务的方法，事务是不会起作用的。

1. 在需要事务管理的地方加@Transactional 注解。@Transactional 注解可以被应用于接口定义和接口方法、类定义和类的 public 方法上。

2. @Transactional 注解只能应用到 public 可见度的方法上。 如果你在 protected、private 或者 package-visible 的方法上使用 @Transactional 注解，它也不会报错， 但是这个被注解的方法将不会展示已配置的事务设置。

3. 注意仅仅 @Transactional 注解的出现不足于开启事务行为，它仅仅 是一种元数据。必须在配置文件中使用配置元素，才真正开启了事务行为。

4. 通过 元素的 "proxy-target-class" 属性值来控制是基于接口的还是基于类的代理被创建。如果 "proxy-target-class" 属值被设置为 "true"，那么基于类的代理将起作用（这时需要CGLIB库cglib.jar在CLASSPATH中）。如果 "proxy-target-class" 属值被设置为 "false" 或者这个属性被省略，那么标准的JDK基于接口的代理将起作用。


标准的JDK基于接口的代理将起作用-->
proxy-target-class="false"/>

基于类的代理将起作用 ,同时 cglib.jar必须在CLASSPATH中
proxy-target-class="true"/>
-->


非JTA事务（即非分布式事务）， 事务配置的时候 ，需要指定dataSource属性（非分布式事务，事务是在数据库创建的链接上开启。）-->


JTA事务（非分布式事务）， 事务配置的时候 ，不能指定dataSource属性（分布式事务，是有全局事务来管理数据库链接的）-->

注解@Transactional cglib与java动态代理最大区别是代理目标对象不用实现接口,那么注解要是写到接口方法上，要是使用cglib代理，这是注解事物就失效了，为了保持兼容注解最好都写到实现类方法上。

5. Spring团队建议在具体的类（或类的方法）上使用 @Transactional 注解，而不要使用在类所要实现的任何接口上。在接口上使用 @Transactional 注解，只能当你设置了基于接口的代理时它才生效。因为注解是 不能继承 的，这就意味着如果正在使用基于类的代理时，那么事务的设置将不能被基于类的代理所识别，而且对象也将不会被事务代理所包装。

6. @Transactional 的事务开启 ，或者是基于接口的 或者是基于类的代理被创建。所以在同一个类中一个方法调用另一个方法有事务的方法，事务是不会起作用的。

public interface PersonService {
//删除指定id的person
public void delete(Integer personid) ;

//删除指定id的person,flag
public void delete(Integer personid,boolean flag) ;
}

public class PersonServiceBean implements PersonService {
private JdbcTemplate jdbcTemplate;

public void delete(Integer personid){
try{
this.delete(personid,true)
System.out.println("delete success");
}catch(Exception e){
System.out.println("delete failed");
}
}

@Transactional
//此时，事务根本就没有开启, 即数据库会默认提交该操作，即记录别删除掉 public void delete(Integer personid,boolean flag){
if(flag == ture){
jdbcTemplate.update("delete from person where id=?", new Object[]{personid},
new int[]{java.sql.Types.INTEGER});
throw new RuntimeException("运行期例外");
}
}
}

public class PersonServiceBeanTest{
PersonService ps = new PersonServiceBean ();
ps.delete(5);
}

7. Spring使用声明式事务处理，默认情况下，如果被注解的数据库操作方法中发生了unchecked异常，所有的数据库操作将rollback；如果发生的异常是checked异常，默认情况下数据库操作还是会提交的。

-----------------------------------------------------------------------------------------------------------------------------------------------
public interface PersonService {
//删除指定id的person
public void delete(Integer personid) ;

//获取person
public Person getPerson(Integer personid);
}

//PersonServiceBean 实现了PersonService 接口，则基于接口的还是基于类的代理 都可以实现事务
@Transactional public class PersonServiceBean implements PersonService {
private JdbcTemplate jdbcTemplate;

//发生了unchecked异常,事务回滚, @Transactional
public void delete(Integer personid){
jdbcTemplate.update("delete from person where id=?", new Object[]{personid},
new int[]{java.sql.Types.INTEGER});
throw new RuntimeException("运行期例外");
}
}

---------------------------------------------------------------------------------------------------------------------------------------------------
public interface PersonService {
//删除指定id的person
public void delete(Integer personid) throws Exception;

//获取person
public Person getPerson(Integer personid);
}

@Transactional
public class PersonServiceBean implements PersonService {

//发生了checked异常,事务不回滚,即数据库记录仍能被删除，
//checked的例外，需要我们在外部用try/catch语法对调用该方法的地方进行包含 @Transactional
public void delete(Integer personid) throws Exception{
jdbcTemplate.update("delete from person where id=?", new Object[]{personid},
new int[]{java.sql.Types.INTEGER});
throw new Exception("运行期例外");
}

}
---------------------------------------------------------------------------------------------------------------------------------------------------
但是，对于checked这种例外，默认情况下它是不会进行事务回滚的，但是如果我们需要它进行事务回滚，这时候可以在delete方法上通过@Transaction这个注解来修改它的行为。

@Transactional
public class PersonServiceBean implements PersonService {

@Transactional(rollbackFor=Exception.class)
//rollbackFor这属性指定了，既使你出现了checked这种例外，那么它也会对事务进行回滚
public void delete(Integer personid) throws Exception{
jdbcTemplate.update("delete from person where id=?", new Object[]{personid},
new int[]{java.sql.Types.INTEGER});
throw new Exception("运行期例外");
}
}
---------------------------------------------------------------------------------------------------------------------------------------------------

在PersonServiceBean这个业务bean里面，有一些事务是不需要事务管理的，好比说获取数据的getPersons方法，getPerson方法。因为@Transactional 放在了类的上面。


此时，可以采用propagation这个事务属性@Transactional(propagation=Propagation.NOT_SUPPORTED)，propagation这个属性指定了事务传播行为，我们可以指定它不支持事务，当我们这么写了之后，Spring容器在getPersons方法执行前就不会开启事务.

@Transactional
public class PersonServiceBean implements PersonService {

@Transactional(propagation=Propagation.NOT_SUPPORTED)
//则此方法 就不会开启事务了
public Person getPerson(Integer personid)
{
}
}


yangcbyang
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring中的@Transactional(rollbackFor = Exception.class)属性详解
dinghuoruo0011的博客
07-16 5682
序言 今天我在写代码的时候，看到了。一个注解@Transactional(rollbackFor = Exception.class)，今天就和大家分享一下，这个注解的用法； 异常 如下图所示，我们都知道Exception分为运行时异常RuntimeException和非运行时异常 error是一定会回滚的 如果不对运行时异常进行处理，那么出现运行时异常之后，要么...
springboot事务回滚源码_浅谈Spring中@Transactional事务回滚及示例（附源码）
weixin_29932613的博客
01-17 407
一、使用场景举例在了解@Transactional怎么用之前我们必须要先知道@Transactional有什么用。下面举个栗子：比如一个部门里面有很多成员，这两者分别保存在部门表和成员表里面，在删除某个部门的时候，假设我们默认删除对应的成员。但是在执行的时候可能会出现这种情况，我们先删除部门，再删除成员，但是部门删除成功了，删除成员的时候出异常了。这时候我们希望如果成员删除失败了，之前删除的部门也...
Spring事务管理Demo
05-01
Spring事务管理Demo
Spring事务的进阶。@Transactional的rollbackFor和propagation属性。
最新发布
2302_79020600的博客
07-08 1231
@Transactional注解当中的第二个属性propagation，这个属性是用来配置事务的传播行为的。什么是事务的传播行为呢？就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行事务控制。例如：两个事务方法，一个A方法，一个B方法。在这两个方法上都添加了@Transactional注解，就代表这两个方法都具有事务，而在A方法当中又去调用了B方法。
@Transactional使用
zhaoyouliang123的博客
10-25 1074
转:https://www.jianshu.com/p/9098372c108a @Transactional(rollbackFor) 概括 @Transactional注解有两个，一个是spring提供的@org.springframework.transaction.annotation.Transactional 另一个是jdk提供@javax.transaction.Transactio...
@Transactional(rollbackFor = Exception.class)详解
GSIBin
04-23 5413
Transactional(rollbackFor = Exception.class)：深入解析Spring的事务管理在Spring框架中，事务管理是一个非常重要的部分，它确保了在执行一系列数据库操作时，如果其中任何一个操作失败，那么整个事务都会被回滚，以保持数据的完整性和一致性。在Spring中，@Transactional注解是实现这一功能的关键。
浅谈Spring中@Transactional事务回滚及示例（附源码）
08-28
浅谈Spring中@Transactional事务回滚及示例 @Transactional是Spring Framework中的一种事务管理机制，用于管理数据库事务。它可以使得数据库操作更加安全和可靠。本文将详细介绍@Transactional的使用场景、checked...
Spring中@Transactional事务回滚（含实例
11-25
本文将深入解析`@Transactional`的事务回滚机制，并通过实例来详细讲解其工作原理，帮助读者理解和应用这一核心功能。 一、`@Transactional`注解介绍 `@Transactional`是Spring提供的一个注解，用于在方法级别或类...
Spring中的@Transactional事物回滚实例源码
12-28
在Spring框架中，`@Transactional`注解是事务管理的核心组件，它允许开发者在方法级别声明事务边界。本文将深入探讨这个注解的工作原理、如何配置以及如何在遇到异常时触发事务回滚。 首先，`@Transactional`是...
Spring-test事务自动回滚 及@Transactional 详解
李利科
01-19 5017
Spring-test事务自动回滚 测试时使用addUser()方法向数据库插入一条记录，结果发现通过单元测试了，但是并没有向数据库插入一条记录。一看日志，发现Spring-test对事务进行了回滚。 为了使测试数据不对数据库造成污染，在使用Spring-test进行的单元测试的时候，默认会对事务进行回滚，即@Rollback 默认是true，如果想要测试数据不回滚，可设置@Rollback(value = false) 。 @Test @Transactional @Rollback(value = fa
Spring事务小demo
05-08
这是一个Spring+Mybatis+Mysqls的Java程序，主要是用来学习Spring的事务的，感兴趣的可以下载。
@Transactional(rollbackFor = Exception.class)
diankui6178的博客
11-06 142
@Transactional(rollbackFor = Exception.class)这个注解只有在出异常时才会回滚，需要回滚时没有异常也要人为制造异常（自定义异常）所以，如果使用了异常捕获，很有可能异常没有被抛出，而是捕获消化了（人为把异常友好的处理了，这种情况不能回滚）总之，尽量不去捕获，让异常自己抛出来 转载于:https://www.cnblogs.com/hellowzd...
Spring Boot事务管理-事务回滚示例
softwareCraftsman
06-24 1319
在先前的教程中，我们已经实现了 Spring Boot事务管理示例 -我们看到了什么是事务并实现了声明式事务管理。在以前的教程 -Spring Boot事务-了解事务传播中， 我们还研究了什么是传播以及使用Spring Boot的不同类型。在下一个教程中，我们将研究 什么是使用Spring Boot的事务隔离。 在Spring Boot事务管理示例中， 我们已经看到应用程序事务是一系列应用程序操作，这些操作被应用程序视为单个逻辑单元。 对于应用程序事务，如果任何操作失败，则所有其他操作都会回滚。在先前的事
Spring事务回滚
Wengzhengcun的博客
07-16 193
Spring支持两种回滚模式，详情看链接的文章。 https://www.cnblogs.com/chen-lhx/p/6956152.html
spring 事务 demo
weixin_30387663的博客
11-22 170
TestUserService 1 import com.demo.service.IUserService; 2 import org.junit.Test; 3 import org.junit.runner.RunWith; 4 import org.springframework.test.context.ContextConfiguration; 5...
@Transactional(rollbackFor = Throwable.class)事务注解讲解，事务传播机制讲解
还在活水泥的未来包工头
11-17 1908
在上面的示例中，我们有一个服务类 UserService，其中有一个方法 updateUser 使用了 REQUIRED 传播行为，另一个方法 internalMethod 使用了 REQUIRES_NEW 传播行为。但是，即使 internalMethod 中抛出了异常，由于它是在同一个类中被调用的，事务传播机制并不会生效，updateUser 方法中的事务也不会回滚。这是因为 Spring 默认使用代理对象来实现事务，而代理对象的方法调用本类内部的另一个方法，并不会触发事务的传播行为。
Spring Boot - @Transactional 手动回滚
A_bad_horse的专栏
09-18 585
Spring Boot - @Transactional 手动回滚
@Transactional(rollbackFor=Exception.class)的使用
weixin_44882521的博客
05-13 2010
@Transactional(rollbackFor=Exception.class)的使用
Spring源码透析：事务控制方法与回滚规则详解
总结，本文通过讲解Spring源码，深入剖析了事务在Spring中的工作原理，涵盖了事务的定义、代码实现以及配置细节。理解这些核心概念有助于开发者更好地管理Spring应用中的事务，确保业务逻辑的稳定性和数据的一致性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值