Spring事务的传播规则以及各种场景下事务的生效情况

置顶 hanxiaozhang2018

已于 2024-01-11 20:55:47 修改

阅读量1.9k

点赞数 3

CC 4.0 BY-SA版权

分类专栏： Spring 文章标签： spring 面试 java 后端

于 2020-05-10 11:37:41 首次发布

本文链接：https://blog.csdn.net/huantai3334/article/details/106033805

Spring 专栏收录该内容

24 篇文章

订阅专栏

本文深入探讨Spring事务管理的关键概念，包括物理事务与逻辑事务的区别、Spring的事务传播规则及嵌套事务的使用技巧。通过具体示例，解析不同传播规则下事务的执行流程与回滚机制，为开发者提供实战指南。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

前言：

从大学学完《Web程序设计》这门课之后，我一直在使用Spring这个框架，它的优点和好处不言而喻。随着时间的推移，我对这个框架的理解也不断加深，自己也有了一些使用的技巧与经验，下面我将分享关于Spring事务中的一些知识，希望对大家的工作、学习、面试有一些帮助。分享的内容主要包括事务何时生效、事务的传播规则和嵌套事务的使用等。如有偏差，请君不吝赐教！

一、相关知识点（这里只写文中用到的知识点）：

1.物理事务与逻辑事务：

物理事务：事务性资源实际打开的事务，如数据库的Connection打开的事务。

逻辑事务：Spring事务，它为每个事务方法创建一个事务范围。在逻辑事务中，大范围的事务称为外围事务，小范围的事务称为内部事务，外围事务可以包含内部事务，但在逻辑上是互相独立的。每一个逻辑事务范围，都能够单独地决定rollback-only状态。

Tips：如何处理逻辑事务与物理事务之间的关联关系，Spring通过传播行为来解决。

2.spring的传播规则：

传播规则定义了事务范围，何时触发事务，是否暂停现有事务等，具体规则如下：

传播规则	作用
PROPAGATION_REQUIRED（默认）	支持当前物理事务，如果当前没有物理事务，就新建一个物理事务。这是最常见的选择
PROPAGATION_REQUIRES_NEW	每次都新建物理事务，如果当前存在物理事务，把当前物理事务挂起
PROPAGATION_SUPPORTS	支持当前物理事务，如果当前没有物理事务，就以非事务方式执行
PROPAGATION_NOT_SUPPORTED	以非事务方式执行操作，如果当前存在事务，就把当前物理事务挂起
PROPAGATION_MANDATORY	支持当前物理事务，如果当前没有事务，就抛出异常
PROPAGATION_NEVER	以非事务方式执行，如果当前存在事务，则抛出异常
PROPAGATION_NESTED	如果当前存在事务，则在当前事务上创建保存点（SavePoint）并开启子事务，子事务与主事务一同提交；如果当前不存在事务，则按REQUIRED属性执行

3.嵌套事务NESTED与REQUIRES_NEW区别：

本质区别：REQUIRES_NEW新创建一个事务，自己提交；而NESTED还在一个事务中，它与主事务一块提交。

其他区别：

（1）NESTED的内层事务可以读取主事务未提交的数据；REQUIRES_NEW却不行，除非内层事务的隔离级别是Read Uncommitted；

（2）NESTED的内层事务执行结束后，外层事务出现异常，内层事务可以回滚；REQUIRES_NEW却不行，因为REQUIRES_NEW的内层事务已提交；

（3）NESTED可以修改同一条数据；REQUIRES_NEW会造成死锁或锁等待超时（我在业务上遇到过锁等待超时，详见《业务上第一次遇到MySQL更新锁表超时（ Lock wait timeout exceeded; try restarting transaction）》）；

（4）REQUIRES_NEW内层事务独自提交后，可以被修改，可能造成A的脏读。

4.Spring AOP的两种代理方式：

方式：JDK动态代理（默认）和CGLIB动态代理

使用：

目标对象实现了接口：默认采用JDK动态代理实现AOP，但可以强制使用CGLIB动态代理实现AOP。

目标对象没有实现接口：必须采用CGLIB库。

二、举例证明：

1.Spring事务默认只处理RuntimeException异常：

证明方法：handleRuntimeExceptionTx(DictTwoDO dict)，该方法直接使用注解的默认值，该方法的内部会抛出一个IO流异常，IO流异常不属于RuntimeException异常。如果调用该方法，事务没有回滚，数据库有插入数据记录，则证明以上结论是正确的。具体方法如下：

   /**
     * 处理运行时异常的事务方法
     *
     * @param dict
     * @throws FileNotFoundException
     */
    @Override
    @Transactional
    public void handleRuntimeExceptionTx(DictTwoDO dict) throws FileNotFoundException {
        dict.setDescription("TxService1:handleRuntimeExceptionTx");
        dictTwoDao.save(dict);
        // 这里会抛一个IO流异常：java.io.FileNotFoundException: E:\a.txt (系统找不到指定的路径。)
        FileInputStream fileInputStream = new FileInputStream("E:\\a.txt");
    }

调用该方法的过程，我这里就不展示了，直接展示数据库的结果：

通过数据库的结果来看，可以证明“Spring事务默认只处理RuntimeException异常”，那如何让Spring事务支持处理非RuntimeException异常呢，其实很简单，只需要在@Transactional注解中配置rollbackFor属性，把该属性设置为Exception.class即可，我们通过handleExceptionTx(DictTwoDO dict)方法测试一下，具体方法如下：

   /**
     * 处理所有异常的事务方法
     *
     * @param dict
     * @throws FileNotFoundException
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void handleExceptionTx(DictTwoDO dict) throws FileNotFoundException {
        dict.setDescription("TxService1:handleExceptionTx");
        dictTwoDao.save(dict);
        // 这里会抛一个IO流异常：java.io.FileNotFoundException: E:\a.txt (系统找不到指定的路径。)
        FileInputStream fileInputStream = new FileInputStream("E:\\a.txt");
    }

调用该方法后，数据库没有插入任何数据，则证明在@Transactional注解中配置rollbackFor属性，把该属性设置为Exception.class可以解决非RuntimeException异常回滚的问题。

2.Spring事务捕获了异常后，事务不会回滚：

证明方法：handleCatchException(DictTwoDO dict)，该方法内部会抛出一个异常，然后用try catch捕获，如果捕获后，事务没有回滚，数据库有插入数据记录，则证明以上结论是正确的。具体方法如下：

   /**
     * 处理捕获异常的事务方法
     *
     * @param dict
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void handleCatchException(DictTwoDO dict) {
        dict.setDescription("TxService1:handleCatchException");
        dictTwoDao.save(dict);
        try {
            throw  new RuntimeException("抛一个异常");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

数据库的结果：

通过数据库的结果来看，可以证明“Spring事务捕获了异常后，事务不会回滚” ，如果去掉try catch捕获后，事务就可以正常回滚了，这里我就不做演示了，文末我会提供源代码的地址，源代码的handleNonCatchException(DictTwoDO dict)方法，支持此结论，大家可以测试一下。

3.Spring事务在同一类之间的方法调用事务是否生效：

方法1：handleNonTxCellTxOneClass(DictTwoDO dict)，证明“同一个类中，没有事务方法调用有事务方法”，结论：事务不生效。具体方法如下：

   /**
     * 同一个类中，处理没有事务方法调用事务方法
     *
     * @param dict
     */
    @Override
    public void handleNonTxCellTxOneClass(DictTwoDO dict) {
        dict.setDescription("TxService1:handleNonTxCellTxOneClass");
        dictTwoDao.save(dict);
        this.tx_1(dict);
    }

    /**
     * 事务方法1
     *
     * @param dict
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void tx_1(DictTwoDO dict) {
        dict.setDescription("TxService1:tx_1");
        dictTwoDao.save(dict);
        throw  new RuntimeException("抛一个异常");
    }

数据库的结果：

方法2：handleTxCellTxOneClass_1(DictTwoDO dict)，证明“同一个类中，事务方法调用事务方法”，结论：事务生效。具体方法如下：

   /**
     * 同一个类中，处理事务方法调用事务方法
     *
     * @param dict
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void handleTxCellTxOneClass_1(DictTwoDO dict) {
        dict.setDescription("TxService1:handleTxCellTxOneClass_1");
        dictTwoDao.save(dict);
        this.tx_2(dict);
        throw  new RuntimeException("抛一个异常");
    }

    /**
     * 事务方法2
     *
     * @param dict
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void tx_2(DictTwoDO dict) {
        dict.setDescription("TxService1:tx_2");
        dictTwoDao.save(dict);
    }

数据库的结果： 无数据插入。则证明事务生效。这么说准确吗？我们仔细看看，这里是一个嵌套事务，在同一个类中，事务方法调用另一个事务方法中，我们先看看方法3，然后再想一想，方法2的说法准确吗?

方法3：handleTxCellTxOneClass_2(DictTwoDO dict)，该方法的外层传播规则：REQUIRED，内层传播规则：REQUIRED_NEW。这里用到了嵌套事务，我先说一下方法3正常情况下的结果：propagationRequiredNewTx_1(DictTwoDO dict)方法会自己提交，handleTxCellTxOneClass_2(DictTwoDO dict)遇到异常后回滚（在文章后边讲嵌套事务时候，我会具体说一下）。但实际结果如何呢，我们测试一下？具体方法如下：

   /**
     * 同一个类中，处理事务方法调用事务方法2
     * 外层传播规则：REQUIRED
     * 内层传播规则：REQUIRED_NEW
     *
     * @param dict
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void handleTxCellTxOneClass_2(DictTwoDO dict) {
        dict.setDescription("TxService1:handleTxCellTxOneClass_2");
        dictTwoDao.save(dict);
        this.propagationRequiredNewTx_1(dict);
        throw  new RuntimeException("抛一个异常");
    }

    /**
     * 使用REQUIRED_NEW传播规则的事务1
     *
     * @param dict
     */
    @Override
    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRES_NEW)
    public void propagationRequiredNewTx_1(DictTwoDO dict) {
        dict.setDescription("TxService1:propagationRequiredNewTx_1:Propagation.REQUIRES_NEW");
        dictTwoDao.save(dict);
    }

数据库的结果： 无数据插入，这是为什么呢？原因是：注解式事物使用Spring AOP机制，而Spring AOP是通过代理机制实现。注解式事物注解在Service类中，Service类实现了接口，所以Spring采用基于JDK接口形式的动态代理，其代理的原理就是对target（Service类就是target）前后左右做拦截。在Service类内部一个方法调用另一个方法时，是target内部的调用（this.method()），并没有走外层的拦截，所有不生效。到此，我们明白了：在同一类中，事务方法调用事务方法，内层方法事务不会生效，作为普通方法加入外层事务。那如何才让内层事物生效呢，我们可以让该Service类强制使用CGLIB动态代理方式，让内层事物生效。我们通过方法4来看一下。

方法4：handleTxCellTxOneClass_3(DictTwoDO dict)，同一个类中，处理事务方法调用事务方法（使用CGLIB动态代理），具体方法如下：

@Slf4j
@Service
//开启GCLIB动态代理
@EnableAspectJAutoProxy(exposeProxy = true)
public class TxServiceImpl1 implements TxService1 {
   
   /**
     * 同一个类中，处理事务方法调用事务方法3（使用CGLIB动态代理）
     *
     * @param dict
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void handleTxCellTxOneClass_3(DictTwoDO dict) {
        dict.setDescription("TxService1:handleTxCellTxOneClass_3:Propagation.REQUIRED");
        dictTwoDao.save(dict);
        ((TxServiceImpl1)AopContext.currentProxy()).propagationRequiredNewTx_1(dict);
        throw  new RuntimeException("抛一个异常");
    }

    /**
     * 使用REQUIRED_NEW传播规则的事务1
     *
     * @param dict
     */
    @Override
    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRES_NEW)
    public void propagationRequiredNewTx_1(DictTwoDO dict) {
        dict.setDescription("TxService1:propagationRequiredNewTx_1:Propagation.REQUIRES_NEW");
        dictTwoDao.save(dict);
    }
}

数据库的结果： 只有内层事物的数据插入成功，证明使用CGLIB动态代理内层事物生效。

4.Spring事务在两个类中，无事务方法调用另一个类事务方法时，只事物方法生效：

证明方法：handleNonTxCellTxTwoClass(DictTwoDO dict)，该方法无事物但会调用另一个类中的事物方法，另一个类中的事物方法会抛出一个异常，如果只事物方法回滚，则证明以上结论是正确的。具体方法如下：

    /**
     * 同两个类中，无事务方法调用另一个类事务方法
     *
     * @param dict
     */
    public void handleNonTxCellTxTwoClass(DictTwoDO dict) {
        dict.setDescription("TxService1:handleNonTxCellTxTwoClass");
        dictTwoDao.save(dict);
        txService2.tx_1(dict);
    }
-------------另一个Service类-----------------
    /**
     * 事务方法1
     *
     * @param dict
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void tx_1(DictTwoDO dict) {
        dict.setDescription("TxService2:tx_1");
        dictTwoDao.save(dict);
        throw  new RuntimeException("抛一个异常");
    }

数据库的结果： 只有无事物的数据插入成功，证明以上结论正确。

5.REQUIRED与REQUIRED_NEW事务传播规则在只有一个事务方法时，效果一样：

证明方法：propagationRequiredTx_1(DictTwoDO dict)，该方法使用REQUIRED传播规则的事务；propagationRequiredNewTx_2(DictTwoDO dict)，该方法使用使用REQUIRED_NEW传播规则的事务。两个方法都会抛出异常，看事物是否回滚，结果一定是都会回滚。那为什么要说一下这呢，我这里想说一下，如何只有一个事物，事物的转播规则的意义不很大，在使用嵌套事物时，传播规则的精髓才得以施展，嵌套事物像是传播规则灵魂的体现。具体的方法如下：

    /**
     * 使用REQUIRED传播规则的事务1
     *
     * @param dict
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void propagationRequiredTx_1(DictTwoDO dict) {
        dict.setDescription("TxService1:propagationRequiredTx_1");
        dictTwoDao.save(dict);
        throw  new RuntimeException("抛一个异常");
    }

    /**
     * 使用REQUIRED_NEW传播规则的事务2
     *
     * @param dict
     */
    @Override
    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRES_NEW)
    public void propagationRequiredNewTx_2(DictTwoDO dict) {
        dict.setDescription("TxService1:propagationRequiredNewTx_2");
        dictTwoDao.save(dict);
        throw  new RuntimeException("抛一个异常");
    }

数据库的结果： 无数据插入

6.嵌套事务，内层事务为REQUIRED_NEW与NESTED的区别：

方法1：handleNestTxOnTwoClass_1(DictTwoDO dict)，该方法外层传播规则：REQUIRED，内层传播规则：REQUIRED_NEW，具体代码如下，通过阅读代码，可能在四处抛出异常，我们分别验证一下：

    /**
     * 同两个类中，处理的嵌套事务1
     * 外层传播规则：REQUIRED
     * 内层传播规则：REQUIRED_NEW
     *
     *
     * @param dict
     */
    @Override
    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
     public void handleNestTxOnTwoClass_1(DictTwoDO dict) {
        dict.setDescription("TxService1:handleNestTxOnTwoClass_1:Propagation.REQUIRED");
        dictTwoDao.save(dict);
        // 声明一个异常  // 第1处
//        int i=1;
//        i=i/0;
        try {
            txService2.propagationRequiredNewTx_1(dict);
        } catch (Exception e) {
            dict.setDescription("TxService1:handleNestTxOnTwoClass_1:fair");
            dictTwoDao.save(dict);
            // 声明一个异常  // 第3处
//        throw  new RuntimeException("抛一个异常");
        }
        dict.setDescription("TxService1:handleNestTxOnTwoClass_1:two");
        dictTwoDao.save(dict);
        // 声明一个异常  // 第4处
//        throw  new RuntimeException("抛一个异常");

    }
-------------另一个Service类-----------------
    /**
     * 使用REQUIRED_NEW传播规则的事务1
     *
     * @param dict
     */
    @Override
    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRES_NEW)
    public void propagationRequiredNewTx_1(DictTwoDO dict) {
        dict.setDescription("TxService2:propagationRequiredNewTx_1:Propagation.REQUIRES_NEW");
        dictTwoDao.save(dict);
        // 声明一个异常  // 第2处
//        throw  new RuntimeException("抛一个异常");
    }

只打开第1处异常，数据库的结果：数据库无数据插入。

只打开第2处异常，数据库的结果：数据库有数据插入，插入结果如下。通过结果发现内层事物异常并自己回滚了，然后被外层捕获了，捕获后存储了一条失败信息。

打开第2和3处异常，数据库的结果：数据库无数据插入，原因内层事物发生异常，自己回滚到，把异常信息抛给了外层事物，外层事物捕获异常后，又声明了一个异常，外层事物也回滚了。

只打开第4处异常，数据库的结果：数据库有数据插入，插入结果如下，通过结果可以看出，内层事物的数据插入成功。

方法2：handleNestTxOnTwoClass_2 (DictTwoDO dict)，该方法外层传播规则：REQUIRED，内层传播规则：NESTED，具体代码如下，通过阅读代码，也有可能在三处抛出异常，我们分别验证一下：

    /**
     * 处理同两个类中的嵌套事务2
     * 外层传播规则：REQUIRED
     * 内层传播规则：NESTED
     *
     * @param dict
     */
    @Override
    @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
    public void handleNestTxOnTwoClass_2(DictTwoDO dict) {

        dict.setDescription("TxService1:handleNestTxOnTwoClass_2:Propagation.REQUIRED");
        dictTwoDao.save(dict);
        // 声明一个异常  // 第1处
//        int i=1;
//        i=i/0;
        try {
            txService2.propagationNestedTx_1(dict);
        } catch (Exception e) {
            dict.setDescription("TxService1:handleNestTxOnTwoClass_2:fair");
            dictTwoDao.save(dict);
            // 声明一个异常  // 第3处
//        throw  new RuntimeException("抛一个异常");
        }
        dict.setDescription("TxService1:handleNestTxOnTwoClass_2:two");
        dictTwoDao.save(dict);
        // 声明一个异常  // 第4处
        throw  new RuntimeException("抛一个异常");
    }
-------------另一个Service类-----------------
    /**
     * 使用NESTED传播规则的事务1
     *
     * @param dict
     */
    @Override
    @Transactional(rollbackFor = Exception.class,propagation = Propagation.NESTED)
    public void propagationNestedTx_1(DictTwoDO dict) {
        dict.setDescription("TxService2:propagationNestedTx_1:Propagation.NESTED");
        dictTwoDao.save(dict);
        // 声明一个异常  // 第2处
//        throw  new RuntimeException("抛一个异常");
    }

只打开第1处异常，数据库的结果：数据库无数据插入。

只打开第2处异常，数据库的结果：数据库有数据插入，插入结果如下。通过结果内层事物出现异常并自己回滚到外层事物的保存点（SavePoint），然后被外层捕获了，捕获后存储了一条失败信息。

打开第2和3处异常，数据库的结果：数据库无数据插入，原因内层事物发生异常，自己回滚到外层事物的保存点（SavePoint），把异常信息抛给了外层事物，外层事物捕获异常后，又声明了一个异常，外层事物也回滚了。

只打开第4处异常，数据库的结果：数据库无数据插入，原因是内外层共享一个事物。

结论：

外层传播规则：REQUIRED，内层传播规则：REQUIRED_NEW 时，内层新开启一个事务。内层事务异常，可能会影响外部事务的回滚，即如果外层事务捕获内层事务的异常，则外层事务不会回滚，如果外层事务不处理内层事务的异常，则外层事务回滚；但外层事务异常，不会影响内部事务的回滚。

外层传播规则：REQUIRED，内层传播规则：NESTED时，内层在当前事务上创建保存点（SavePoint）并开启子事务，子事务会与主事务一同提交。内层事务异常，将回滚到它执行前的保存点（SavePoint)，此时，如果外层事务捕获内层事务的异常，则外层事务不会回滚，如果外层事务不处理内层事务的异常，则外层事务回滚；但外层事务异常，内部事务也会回滚。