Spring中事务嵌套这么用一定得注意了！！

Posted JAVA旭阳

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Spring中事务嵌套这么用一定得注意了！！相关的知识，希望对你有一定的参考价值。

前言

最近项目上有一个使用事务相对复杂的业务场景报错了。在绝大多数情况下，都是风平浪静，没有问题。其实内在暗流涌动，在有些异常情况下就会报错，这种偶然性的问题很有可能就会在暴露到生产上造成事故，那究竟是怎么回事呢？

问题描述

我们用一个简单的例子模拟下，大家也可以看看下面这段代码输出的结果是什么。

  1. 在类SecondTransactionService定义一个简单接口transaction2，插入一个用户，同时必然会抛出错误
@Override
@Transactional(rollbackFor = Exception.class)
public void transaction2() 
    System.out.println("do transaction2.....");
    User user = new User("tx2", "111", 18);
    // 插入一个用户
    userService.insertUser(user);
    // 跑错了
    throw new RuntimeException();
  1. 在另外一个类FirstTransactionService定义一个接口transaction1，它调用transaction2方法，同时做了try catch处理
@Override
@Transactional(rollbackFor = Exception.class)
public void transaction1() 
    System.out.println("do transaction1 .......");
    try 
        // 调用另外一个事务，try catch住
        secondTransactionService.transaction2();
     catch (Exception e) 
        e.printStackTrace();
    

    // 插入当前用户tx1
    User user = new User("tx1", "111", 18);
    userService.insertUser(user);
  1. 定义一个controller，调用transaction1方法
@GetMapping("/testNestedTx")
public String testNestedTx() 
    firstTransactionService.transaction1();
    return "success";

大家觉得调用这个http接口，最终数据库插入的是几条数据呢？

问题结果

正确答案是数据库插入了0条数据。

同时控制台也报错了，报错原因是：org.springframework.transaction.UnexpectedRollbackException: Transaction rolled back because it has been marked as rollback-only

是否和你预想的一样呢？你知道是为什么吗？

原因追溯

其实原因很简单，我们都知道，一个事务要么全成功提交事务，要么失败全部回滚。如果出现在一个事务中部分SQL要回滚，部分SQL要提交，这不就主打的一个”前后矛盾，精神分裂“吗？

controller.testNestedTx() 
  || 
  / 
FirstTransactionService.transaction1()   REQUIRED隔离级别
       || 
       || 
       || 捕获异常，提交事务，出错啦
       / || 
FirstTransactionService.transaction2()   REQUIRED隔离级别
       || || 
       || 抛出异常,标记事务为rollback only
       =======================
  1. 事务的隔离级别为REQUIRED，那么发现没有事务开启一个事务操作，有的话，就合并到这个事务中，所以transaction1()、transaction2()是在同一个事务中。
  2. transaction2()抛出异常，那么事务会被标记为rollback only, 源码如下所示：

  1. transaction1()由于try catch 异常，正常运行，想必就要可以提交事务了，在提交事务的时候，会检查rollback标记，如果是true, 这时候就会抛出上面的异常了。源码如下图所示：

这下，是不是很清楚知道报错的原因了，那想想该怎么处理呢？

解决之道

知道了根本原因之后，是不是解决的方案就很明朗了，我们可以通过调整事务的传播方式分拆多个事务管理，或者让一个事务"前后一致"，做一个诚信的好事务。

  • 将try catch放到内层事务中，也就是transaction2()方法中，这样内层事务会跟着外部事务进行提交或者回滚。
@Override
    @Transactional(rollbackFor = Exception.class)
    public void transaction2() 
        try 
            System.out.println("do transaction2.....");
            User user = new User("tx2", "111", 18);
            userService.insertUser2(user);
            throw new RuntimeException();
         catch (Exception e) 
            e.printStackTrace();
  • 如果希望内层事务抛出异常时中断程序执行，直接在外层事务的catch代码块中抛出e，这样同一个事务就都会回滚。
  • 如果希望内层事务回滚，但不影响外层事务提交，需要将内层事务的传播方式指定为PROPAGATION_NESTED。PROPAGATION_NESTED基于数据库savepoint实现的嵌套事务，外层事务的提交和回滚能够控制嵌内层事务，而内层事务报错时，可以返回原始savepoint，外层事务可以继续提交。

事务的传播机制

前面提到了事务的传播机制，我们再看都有哪几种。

  • PROPAGATION_REQUIRED：加入到当前事务中，如果当前没有事务，就新建一个事务。这是最常见的选择，也是Spring中默认采用的方式。
  • PROPAGATION_SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行。
  • PROPAGATION_MANDATORY ：支持当前事务，如果当前没有事务，就抛出异常。
  • PROPAGATION_REQUIRES_NEW：新建一个事务，如果当前存在事务，把当前事务挂起。
  • PROPAGATION_NOT_SUPPORTED ：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
  • PROPAGATION_NEVER： 以非事务方式执行，如果当前存在事务，则抛出异常。
  • PROPAGATION_NESTED ：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则进行与PROPAGATION_REQUIRED类似的操作。

如何理解PROPAGATION_NESTED的传播机制呢，和PROPAGATION_REQUIRES_NEW又有什么区别呢？我们用一个例子说明白。

  • 定义serviceA.methodA()以PROPAGATION_REQUIRED修饰；
  • 定义serviceB.methodB()以表格中三种方式修饰；
  • methodA中调用methodB;

总结

在我的项目中之所以会报“rollback-only”异常的根本原因是代码风格不一致的原因。外层事务对错误的处理方式是返回true或false来告诉上游执行结果，而内层事务是通过抛出异常来告诉上游（这里指外层事务）执行结果，这种差异就导致了“rollback-only”异常。大家也可以去review自己项目中的代码，是不是也偷偷犯下同样的错误了。

欢迎关注个人公众号【JAVA旭阳】交流学习

深入理解事务--Spring事务的传播机制

https://blog.csdn.net/yuanlaishini2010/article/details/45792069

 

事务的嵌套概念

所谓事务的嵌套就是两个事务方法之间相互调用。spring事务开启 ，或者是基于接口的或者是基于类的代理被创建（注意一定要是代理，不能手动new 一个对象，并且此类（有无接口都行）一定要被代理——spring中的bean只要纳入了IOC管理都是被代理的）。所以在同一个类中一个方法调用另一个方法有事务的方法，事务是不会起作用的。
 
###
Spring默认情况下会对运行期例外(RunTimeException)，即uncheck异常，进行事务回滚。
如果遇到checked异常就不回滚。
如何改变默认规则：

1 让checked例外也回滚：在整个方法前加上 @Transactional(rollbackFor=Exception.class)


2 让unchecked例外不回滚： @Transactional(notRollbackFor=RunTimeException.class)


3 不需要事务管理的(只查询的)方法：@Transactional(propagation=Propagation.NOT_SUPPORTED)
上面三种方式也可在xml配置
 

spring事务传播属性

 在 spring的 TransactionDefinition接口中一共定义了六种事务传播属性：
 
PROPAGATION_REQUIRED -- 支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。 
PROPAGATION_SUPPORTS -- 支持当前事务，如果当前没有事务，就以非事务方式执行。 
PROPAGATION_MANDATORY -- 支持当前事务，如果当前没有事务，就抛出异常。 
PROPAGATION_REQUIRES_NEW -- 新建事务，如果当前存在事务，把当前事务挂起。 
PROPAGATION_NOT_SUPPORTED -- 以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。 
PROPAGATION_NEVER -- 以非事务方式执行，如果当前存在事务，则抛出异常。 
PROPAGATION_NESTED -- 如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则进行与PROPAGATION_REQUIRED类似的操作。 
前六个策略类似于EJB CMT，第七个（PROPAGATION_NESTED）是Spring所提供的一个特殊变量。 
它要求事务管理器或者使用JDBC 3.0 Savepoint API提供嵌套事务行为（如Spring的DataSourceTransactionManager） 
 
 
举例浅析Spring嵌套事务
ServiceA#methodA(我们称之为外部事务)，ServiceB#methodB(我们称之为外部事务)
 
  1.  
    ServiceA {
  2.  
     
  3.  
    void methodA() {
  4.  
    ServiceB.methodB();
  5.  
    }
  6.  
     
  7.  
    }
  8.  
     
  9.  
    ServiceB {
  10.  
     
  11.  
    void methodB() {
  12.  
    }
  13.  
     
  14.  
    }
 

PROPAGATION_REQUIRED

假如当前正要执行的事务不在另外一个事务里，那么就起一个新的事务 
比如说，ServiceB.methodB的事务级别定义为PROPAGATION_REQUIRED, 那么由于执行ServiceA.methodA的时候
  1、如果ServiceA.methodA已经起了事务，这时调用ServiceB.methodB，ServiceB.methodB看到自己已经运行在ServiceA.methodA的事务内部，就不再起新的事务。这时只有外部事务并且他们是共用的，所以这时ServiceA.methodA或者ServiceB.methodB无论哪个发生异常methodA和methodB作为一个整体都将一起回滚。
  2、如果ServiceA.methodA没有事务，ServiceB.methodB就会为自己分配一个事务。这样，在ServiceA.methodA中是没有事务控制的。只是在ServiceB.methodB内的任何地方出现异常，ServiceB.methodB将会被回滚，不会引起ServiceA.methodA的回滚
 

PROPAGATION_SUPPORTS

如果当前在事务中，即以事务的形式运行，如果当前不再一个事务中，那么就以非事务的形式运行 

PROPAGATION_MANDATORY

必须在一个事务中运行。也就是说，他只能被一个父事务调用。否则，他就要抛出异常

PROPAGATION_REQUIRES_NEW

启动一个新的, 不依赖于环境的 "内部" 事务. 这个事务将被完全 commited 或 rolled back 而不依赖于外部事务, 它拥有自己的隔离范围, 自己的锁, 等等. 当内部事务开始执行时, 外部事务将被挂起, 内务事务结束时, 外部事务将继续执行. 
 比如我们设计ServiceA.methodA的事务级别为PROPAGATION_REQUIRED，ServiceB.methodB的事务级别为PROPAGATION_REQUIRES_NEW，那么当执行到ServiceB.methodB的时候，ServiceA.methodA所在的事务就会挂起，ServiceB.methodB会起一个新的事务，等待ServiceB.methodB的事务完成以后，他才继续执行。他与PROPAGATION_REQUIRED 的事务区别在于事务的回滚程度了。因为ServiceB.methodB是新起一个事务，那么就是存在两个不同的事务。
1、如果ServiceB.methodB已经提交，那么ServiceA.methodA失败回滚，ServiceB.methodB是不会回滚的。
2、如果ServiceB.methodB失败回滚，如果他抛出的异常被ServiceA.methodA的try..catch捕获并处理，ServiceA.methodA事务仍然可能提交；如果他抛出的异常未被ServiceA.methodA捕获处理，ServiceA.methodA事务将回滚。
 
使用场景：
不管业务逻辑的service是否有异常，Log Service都应该能够记录成功，所以Log Service的传播属性可以配为此属性。最下面将会贴出配置代码。
 

PROPAGATION_NOT_SUPPORTED

当前不支持事务。比如ServiceA.methodA的事务级别是PROPAGATION_REQUIRED ，而ServiceB.methodB的事务级别是PROPAGATION_NOT_SUPPORTED ，那么当执行到ServiceB.methodB时，ServiceA.methodA的事务挂起，而他以非事务的状态运行完，再继续ServiceA.methodA的事务。

PROPAGATION_NEVER

不能在事务中运行。假设ServiceA.methodA的事务级别是PROPAGATION_REQUIRED， 而ServiceB.methodB的事务级别是PROPAGATION_NEVER ，那么ServiceB.methodB就要抛出异常了。 

PROPAGATION_NESTED

开始一个 "嵌套的" 事务,  它是已经存在事务的一个真正的子事务. 潜套事务开始执行时,  它将取得一个 savepoint. 如果这个嵌套事务失败, 我们将回滚到此 savepoint. 潜套事务是外部事务的一部分, 只有外部事务结束后它才会被提交. 
 
比如我们设计ServiceA.methodA的事务级别为PROPAGATION_REQUIRED，ServiceB.methodB的事务级别为PROPAGATION_NESTED，那么当执行到ServiceB.methodB的时候，ServiceA.methodA所在的事务就会挂起，ServiceB.methodB会起一个新的子事务并设置savepoint，等待ServiceB.methodB的事务完成以后，他才继续执行。。因为ServiceB.methodB是外部事务的子事务，那么
1、如果ServiceB.methodB已经提交，那么ServiceA.methodA失败回滚，ServiceB.methodB也将回滚。
2、如果ServiceB.methodB失败回滚，如果他抛出的异常被ServiceA.methodA的try..catch捕获并处理，ServiceA.methodA事务仍然可能提交；如果他抛出的异常未被ServiceA.methodA捕获处理，ServiceA.methodA事务将回滚。
理解Nested的关键是savepoint。他与PROPAGATION_REQUIRES_NEW的区别是：
PROPAGATION_REQUIRES_NEW 完全是一个新的事务,它与外部事务相互独立； 而 PROPAGATION_NESTED 则是外部事务的子事务, 如果外部事务 commit, 嵌套事务也会被 commit, 这个规则同样适用于 roll back. 
 

在 spring 中使用 PROPAGATION_NESTED的前提：

1. 我们要设置 transactionManager 的 nestedTransactionAllowed 属性为 true, 注意, 此属性默认为 false!!! 

2. java.sql.Savepoint 必须存在, 即 jdk 版本要 1.4+ 

3. Connection.getMetaData().supportsSavepoints() 必须为 true, 即 jdbc drive 必须支持 JDBC 3.0 


确保以上条件都满足后, 你就可以尝试使用 PROPAGATION_NESTED 了. 
 
 
##############################################################################

Log Service配置事务传播

不管业务逻辑的service是否有异常，Log Service都应该能够记录成功，通常有异常的调用更是用户关心的。Log Service如果沿用业务逻辑Service的事务的话在抛出异常时将没有办法记录日志(事实上是回滚了)。所以希望Log Service能够有独立的事务。日志和普通的服务应该具有不同的策略。Spring 配置文件transaction.xml:
  1.  
    <?xml version="1.0" encoding="UTF-8"?>
  2.  
    <beans xmlns="http://www.springframework.org/schema/beans"
  3.  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
  4.  
    xmlns:tx="http://www.springframework.org/schema/tx"
  5.  
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">
  6.  
    <!-- configure transaction -->
  7.  
     
  8.  
    <tx:advice id="defaultTxAdvice" transaction-manager="transactionManager">
  9.  
    <tx:attributes>
  10.  
    <tx:method name="get*" read-only="true" />
  11.  
    <tx:method name="query*" read-only="true" />
  12.  
    <tx:method name="find*" read-only="true" />
  13.  
    <tx:method name="*" propagation="REQUIRED" rollback-for="java.lang.Exception" />
  14.  
    </tx:attributes>
  15.  
    </tx:advice>
  16.  
     
  17.  
    <tx:advice id="logTxAdvice" transaction-manager="transactionManager">
  18.  
    <tx:attributes>
  19.  
    <tx:method name="get*" read-only="true" />
  20.  
    <tx:method name="query*" read-only="true" />
  21.  
    <tx:method name="find*" read-only="true" />
  22.  
    <tx:method name="*" propagation="REQUIRES_NEW"
  23.  
    rollback-for="java.lang.Exception" />
  24.  
    </tx:attributes>
  25.  
    </tx:advice>
  26.  
     
  27.  
    <aop:config>
  28.  
    <aop:pointcut id="defaultOperation"
  29.  
    expression="@within(com.homent.util.DefaultTransaction)" />
  30.  
    <aop:pointcut id="logServiceOperation"
  31.  
    expression="execution(* com.homent.service.LogService.*(..))" />
  32.  
     
  33.  
    <aop:advisor advice-ref="defaultTxAdvice" pointcut-ref="defaultOperation" />
  34.  
    <aop:advisor advice-ref="logTxAdvice" pointcut-ref="logServiceOperation" />
  35.  
    </aop:config>
  36.  
    </beans>
 
 如上面的Spring配置文件所示，日志服务的事务策略配置为propagation="REQUIRES_NEW"，告诉Spring不管上下文是否有事务，Log Service被调用时都要求一个完全新的只属于Log Service自己的事务。通过该事务策略，Log Service可以独立的记录日志信息，不再受到业务逻辑事务的干扰。























以上是关于Spring中事务嵌套这么用一定得注意了！！的主要内容，如果未能解决你的问题，请参考以下文章

Spring001--事务的传播机制

Spring嵌套事务控制

spring 嵌套事务问题

Spring事务之传播机制

Spring 事务管理高级应用难点剖析: 第 1 部分

Spring嵌套事务原理