详解事务的7种传播行为

最新推荐文章于 2024-09-22 19:23:16 发布
最新推荐文章于 2024-09-22 19:23:16 发布
阅读量5.8w 收藏 355
点赞数 118
分类专栏： Spring高手之路 文章标签： 事务传播 事务 事务传播行为 事务传播方式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34115899/article/details/115602002
版权

文章目录

一、什么是Spring事务的传播行为？

  事务传播行为是指多个拥有事务的方法在嵌套调用时的事务控制方式
比如XML中配置：XML:<tx:method name="..." propagation="REQUIRED"/>
注解配置：@Transactional(propagation=Propagation.REQUIRED)

二、事务传播行为的七种类型

三、Propagation.REQUIRED（默认）

  如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。

例子如下，后续各种情况将此例子展开讲解。

	......
	// ===========测试类
    @Transactional(propagation = Propagation.REQUIRED)
    public void testPropagationTrans() {
    	saveParent();
        saveChildren();
    }
    ......


    // ===========service实现类
    public void saveParent() {
        Stu stu = new Stu();
        stu.setName("parent");
        stu.setAge(19);
        stuMapper.insert(stu); // 数据库插入一条parent记录
    }
    // @Transactional(propagation = Propagation.REQUIRED)
    public void saveChildren() {
        saveChild1();
        int a = 1 / 0;
        saveChild2();
    }

    public void saveChild1() {
        Stu stu1 = new Stu();
        stu1.setName("child-1");
        stu1.setAge(11);
        stuMapper.insert(stu1); // 数据库插入一条child-1记录
    }
    public void saveChild2() {
        Stu stu2 = new Stu();
        stu2.setName("child-2");
        stu2.setAge(22);
        stuMapper.insert(stu2); // 数据库插入一条child-2记录
    }

结果是除以0错误java.lang.ArithmeticException: / by zero

这个例子中，有一个子方法saveParent()是没写事务注解的，用于对照比较有事务的子方法saveChildren()

情况一：
父方法testPropagationTrans()开启事务，子方法saveChildren()没有开启事务。

子方法saveChildren()和saveParent()同处在父方法的事务中，saveChildren()除以0异常导致事务中对数据库的操作都回滚。所以没有记录插入。

在这里插入图片描述
情况二：
父方法testPropagationTrans()不开启事务，只有saveChildren()开启事务

	......
	// ==========测试类
	// @Transactional(propagation = Propagation.REQUIRED)
    public void testPropagationTrans() {
    	saveParent();
        saveChildren();
    }
    ......
    
	// ===========service实现类
    public void saveParent() {
        Stu stu = new Stu();
        stu.setName("parent");
        stu.setAge(19);
        stuMapper.insert(stu); // 数据库插入一条parent记录
    }
    @Transactional(propagation = Propagation.REQUIRED)
    public void saveChildren() {
        saveChild1();
        int a = 1 / 0;
        saveChild2();
    }

    public void saveChild1() {
        Stu stu1 = new Stu();
        stu1.setName("child-1");
        stu1.setAge(11);
        stuMapper.insert(stu1); // 数据库插入一条child-1记录
    }
    public void saveChild2() {
        Stu stu2 = new Stu();
        stu2.setName("child-2");
        stu2.setAge(22);
        stuMapper.insert(stu2); // 数据库插入一条child-2记录
    }

在这里插入图片描述
只有saveChildren()开启事务，saveChildren()发生异常就回滚该方法里面的数据库操作，所以数据库插入一条parent记录还是可以成功的。

情况三：
父方法testPropagationTrans()和子方法saveChildren()均开启事务。这里不拉出多余代码，文字解释+结果图即可。
在这里插入图片描述
saveChildren()发生异常，开始回滚，异常继续往上抛，父方法testPropagationTrans()也知道发生了异常，父方法里面所有数据库操作都回滚，所以saveParent()数据库插入的parent记录也回滚，最后数据库没有数据插入。


疑问：异常继续往上抛父方法才知道发生了异常，导致方法里所有数据库操作回滚，那么我把这个异常try-catch，是不是就只有saveChildren()回滚呢？那可不一定，跟着我继续来看。

四、将异常try-catch捕获，事务是否还会回滚？（这个总结很重要）

所有的讲解都是围绕开头第一段代码，依然是情况一二三，只不过此时多了try-catch

......
    public void testPropagationTrans() {
    	saveParent();
    	try {
            saveChildren();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
......

情况一：
父方法testPropagationTrans()开启事务，子方法saveChildren()没有开启事务。
在这里插入图片描述
saveChildren()产生的异常被捕获，没有继续上抛，父方法开启的事务不会回滚，故插入2条数据。

情况二：
父方法testPropagationTrans()不开启事务，只有saveChildren()开启事务.
在这里插入图片描述
saveChildren()发生异常，回滚数据，parent记录插入不受影响。

情况三：
父方法testPropagationTrans()和子方法saveChildren()均开启事务。
在这里插入图片描述
结果发现即使saveChildren()产生的异常被try-catch，父事务也回滚。

综上：
  1. 父方法和子方法都开启事务，异常发生让子事务回滚，父事务一定回滚(子事务没将父事务挂起的情况下)，不管是否被try-catch包裹，第四节的情况三就是最好的例子。
  2. 只要try-catch在内层，@Transactional在外层，异常被try-catch住，事务就不会回滚。
  3. 但是如果@Transactional在内层，try-catch在外层，那try-catch还没来得及处理异常就在@Transactional注解作用下回滚了，第四节的情况二就是最好的例子。

五、Propagation.SUPPORTS

  如果当前有事务，则使用事务，如果当前没有事务，就以非事务方式执行

情况一：
父方法testPropagationTrans()不开启事务，子方法saveChildren()事务传播类型改为Propagation.SUPPORTS
在这里插入图片描述
外层父方法没有事务，子方法saveChildren()也就以非事务方式执行，这里不会回滚，所以有2条数据。

情况二：
父方法testPropagationTrans()开启事务，传播类型为Propagation.REQUIRED，子方法saveChildren()事务传播类型改为Propagation.SUPPORTS
在这里插入图片描述
子方法saveChildren()当前父方法开启了事务，故使用事务，saveChildren()发生异常回滚，这里子事务没将父事务挂起，子事务回滚，父事务一定回滚，正好验证了前面说过的结论，所以这里没有记录。

六、Propagation.MANDATORY

  支持当前的事务，如果当前没有事务，就抛出异常。
情况一：
父方法testPropagationTrans()不开启事务，子方法saveChildren()事务传播类型改为Propagation.MANDATORY
在这里插入图片描述
此时saveChildren()直接抛出异常，和之前的除以0异常不同， No existing transaction found for transaction marked with propagation 'mandatory'，外层没有事务，就会抛异常。
在这里插入图片描述
异常导致saveChildren()方法没执行，没有child-1记录插入，但是数据库会插入parent记录，因为父方法没开启事务，不影响saveParent()的执行。

情况二：
父方法testPropagationTrans()开启事务，传播类型为Propagation.REQUIRED，子方法saveChildren()事务传播类型改为Propagation.MANDATORY
在这里插入图片描述
子方法saveChildren()支持父事务，故使用事务，saveChildren()发生异常回滚，这里子事务没将父事务挂起，子事务回滚，父事务一定回滚，正好验证了前面说过的结论，所以这里没有记录。

七、Propagation.REQUIRES_NEW

  新建事务，如果当前存在事务，把当前事务挂起。

这里说得多一些，所以代码整个给出来

	......
	// ==========测试类
    @Transactional(propagation = Propagation.REQUIRED)
    public void testPropagationTrans() {
    	saveParent();
        saveChildren();
    }
    ......

	// ===========service实现类

    public void saveParent() {
        Stu stu = new Stu();
        stu.setName("parent");
        stu.setAge(19);
        stuMapper.insert(stu); // 数据库插入一条parent记录
    }
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void saveChildren() {
        saveChild1();
        int a = 1 / 0;
        saveChild2();
    }

    public void saveChild1() {
        Stu stu1 = new Stu();
        stu1.setName("child-1");
        stu1.setAge(11);
        stuMapper.insert(stu1); // 数据库插入一条child-1记录
    }
    public void saveChild2() {
        Stu stu2 = new Stu();
        stu2.setName("child-2");
        stu2.setAge(22);
        stuMapper.insert(stu2); // 数据库插入一条child-2记录
    }

在这里插入图片描述

有人会疑问了，saveChildren() 都新建事务将原事务挂起了，为什么子事务回滚父事务也会回滚？原来的事务都挂起了，子事务回滚和父事务回滚没有必然联系了。 其实这里原因是因为异常抛给了父事务，导致回滚。我们可以将saveChildren()用try-catch包裹，就会发现，testPropagationTrans()所在的事务并没有回滚，因为parent记录插入成功了。
在这里插入图片描述
为了不混淆，我们将异常提出来

	......
	// ==========测试类
    @Transactional(propagation = Propagation.REQUIRED)
    public void testPropagationTrans() {
    	saveParent();
        saveChildren();
        int a = 1 / 0;  // =======将saveChildren的异常提到外面=============
    }
    ......

	// ===========service实现类
    public void saveParent() {
        Stu stu = new Stu();
        stu.setName("parent");
        stu.setAge(19);
        stuMapper.insert(stu); // 数据库插入一条parent记录
    }
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void saveChildren() {
        saveChild1();
        saveChild2();
    }

    public void saveChild1() {
        Stu stu1 = new Stu();
        stu1.setName("child-1");
        stu1.setAge(11);
        stuMapper.insert(stu1); // 数据库插入一条child-1记录
    }
    public void saveChild2() {
        Stu stu2 = new Stu();
        stu2.setName("child-2");
        stu2.setAge(22);
        stuMapper.insert(stu2); // 数据库插入一条child-2记录
    }

在这里插入图片描述
两条child记录插入成功，而parent记录没插入，说明子事务执行完就commit了，父事务所有相关数据库的操作全部回滚，parent记录的插入被撤销，但这也影响不了已经commit的子事务。

举个形象的例子，小区的人都用小区网，我觉得小区网太慢了，自己拉了一根光纤，某天因施工小区网断掉了，大家都受到影响，但是我自己的网不受影响。

八、Propagation.NOT_SUPPORTED

  以非事务方式执行操作，如果当前存在事务，就把当前事务挂起

	......
	// ==========测试类
    @Transactional(propagation = Propagation.REQUIRED)
    public void testPropagationTrans() {
    	saveParent();
        saveChildren();
    }
    ......

	// ===========service实现类
    public void saveParent() {
        Stu stu = new Stu();
        stu.setName("parent");
        stu.setAge(19);
        stuMapper.insert(stu); // 数据库插入一条parent记录
    }
    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    public void saveChildren() {
        saveChild1();
        int a = 1 / 0;  // ===============这里有异常===========
        saveChild2();
    }

    public void saveChild1() {
        Stu stu1 = new Stu();
        stu1.setName("child-1");
        stu1.setAge(11);
        stuMapper.insert(stu1); // 数据库插入一条child-1记录
    }
    public void saveChild2() {
        Stu stu2 = new Stu();
        stu2.setName("child-2");
        stu2.setAge(22);
        stuMapper.insert(stu2); // 数据库插入一条child-2记录
    }

在这里插入图片描述
结果是child-1记录插入成功，parent没有插入成功。原因是saveChildren()以非事务方式执行，并将父事务挂起，执行之后发生异常，但是child-1插入成功，异常抛到父事务后数据库操作全部回滚，所以parent没有插入成功。

这种情况主要用在查询操作，比如在类上开启了事务，类里面的所有方法都开启了事务，插入删除更新是需要的，但是查询就没必要了，所以可以用这个Propagation.NOT_SUPPORTED将查询方法以非事务的方式执行。

九、Propagation.NEVER

  以非事务方式执行，如果当前存在事务，则抛出异常。与Propagation.MANDATORY正好相反。

	......
	// ==========测试类
    @Transactional(propagation = Propagation.REQUIRED)
    public void testPropagationTrans() {
    	saveParent();
        saveChildren();
    }
    ......


	// ===========service实现类
    public void saveParent() {
        Stu stu = new Stu();
        stu.setName("parent");
        stu.setAge(19);
        stuMapper.insert(stu); // 数据库插入一条parent记录
    }
    @Transactional(propagation = Propagation.NEVER)
    public void saveChildren() {
        saveChild1();
        int a = 1 / 0;  // ===============这里有异常===========
        saveChild2();
    }

    public void saveChild1() {
        Stu stu1 = new Stu();
        stu1.setName("child-1");
        stu1.setAge(11);
        stuMapper.insert(stu1); // 数据库插入一条child-1记录
    }
    public void saveChild2() {
        Stu stu2 = new Stu();
        stu2.setName("child-2");
        stu2.setAge(22);
        stuMapper.insert(stu2); // 数据库插入一条child-2记录
    }

结果异常Existing transaction found for transaction marked with propagation 'never'
在这里插入图片描述
在这里插入图片描述
数据库也没有记录，因为parent记录插入后，收到saveChildren()的异常导致父事务回滚，而saveChildren()因为注解检查到异常，内容就没执行。如果去掉testPropagationTrans()事务，那么执行如下，方法都是以非事务方式执行。
在这里插入图片描述

十、Propagation.NESTED

如果当前有事务，则开启子事务（嵌套事务），嵌套事务是独立提交或者回滚，如果当前没有事务，就新建事务运行。

运行结果和原因与Propagation.REQUIRED一模一样。几乎没区别，这种情况用得少。


欢迎一键三连~

有问题请留言，大家一起探讨学习

----------------------Talk is cheap, show me the code-----------------------
砖业洋__
关注
专栏目录
解密Java事务传播行为与隔离级别：案例详解与解决方案
weixin_44976692的博客
02-26 2万+
在实际开发中，根据具体业务需求和数据库环境，选择合适的事务传播行为和隔离级别非常重要，以确保事务的正确性和可靠性。在这个示例中，由于事务隔离级别是READ_COMMITTED，可能会导致读取和更新之间其他事务的影响，解决方案是在更新数据之前重新读取一次，确保数据的一致性。在这个示例中，设置了事务的超时时间为30秒，如果更新操作的执行时间超过了30秒，事务将会被回滚，可以避免长时间占用数据库连接。下面是针对事务传播行为和隔离级别的更丰富的代码示例，包括了多种不同情况下的使用方法和解决方案。
Spring事务传播行为详解
刘树之的博客
08-17 636
前言 Spring在TransactionDefinition接口中规定了7种类型的事务传播行为。事务传播行为是Spring框架独有的事务增强(通知)特性，是Spring为我们提供的强大的工具箱，使用事务传播行可以为我们的开发工作提供许多便利。但是人们对他的误解也颇多，你一定也听过“service方法事务最好不要嵌套”的传言。要想正确的使用工具首先需要了解工具。本文对七种事务传播行为做详细介绍，内容主要代码示例的方式呈现。 基础概念 1.什么是事务传播行为？ 事务传播行为用来描述由某一个事务传播行为修饰的方
事务的7种传播行为
glenshappy的专栏
10-14 4713
另一方面, PROPAGATION_NESTED 开始一个 “嵌套的” 事务, 它是已经存在事务的一个真正的子事务. 潜套事务开始执行时, 它将取得一个 savepoint. 如果这个嵌套事务失败, 我们将回滚到此 savepoint. 潜套事务是外部事务的一部分, 只有外部事务结束后它才会被提交。两个事务不是一个真正的嵌套事务。举例说明：有两个事务方法，一个是方法A，一个是方法B，方法A中调用了方法B，那方法B是开启一个事务运行还是在方法A中的事务中运行，是由方法B的事务传播行为控制的。
[Spring]事务的七个传播行为
Konaji
03-20 5646
前言 当我们调用一个基于Spring的Service接口方法时，它将运行于Spring管理的事务环境中，Service接口方法可能会在内部调用其它的Service接口方法以共同完成一个完整的业务操作，因此就会产生服务接口方法嵌套调用的情况， Spring通过事务传播行为控制当前的事务如何传播到被嵌套调用的目标服务接口方法中。 事务传播是Spring进行事务管理的重要概念，其重要性怎么强调都不为...
Spring高手之路24——事务类型及传播行为实战指南
最新发布
卓越无关环境，保持空杯心态——靡不有初，鲜克有终
09-22 1万+
本篇文章深入探讨了Spring中的事务管理，特别是事务传播行为（如REQUIRES_NEW和NESTED）的应用与区别。通过详实的示例和优化的时序图，全面解析如何在实际项目中使用这些高级事务控制技巧，以提升开发者的Spring事务管理能力。
【Spring学习34】Spring事务(4)：事务属性之7种传播行为
热门推荐
程序老兵的博客
04-20 1万+
事务传播行为什么叫事务传播行为？听起来挺高端的，其实很简单。 即然是传播，那么至少有两个东西，才可以发生传播。单体不存在传播这个行为。事务传播行为（propagation behavior）指的就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行。 例如：methodA事务方法调用methodB事务方法时，methodB是继续在调用者methodA的事务中运行呢，还是为自己开启一个
Spring的事务传播机制(通俗易懂)
Samdom的博客
06-05 1万+
概述 Spring的传播机制有7种，在枚举Propagation中有定义。 1.REQUIRED PROPAGATION_REQUIRED：如果当前没有事务，就创建一个新事务，如果当前存在事务，就加入该事务，该设置是最常用的默认设置。 @Transactional(propagation= Propagation.REQUIRED) public void methodA(){ methodB(); // do something } @Transactional(propagation= P
Spring事务传播行为
bigliu123的专栏
07-03 326
事务传播行为 什么叫事务传播行为？听起来挺高端的，其实很简单。 即然是传播，那么至少有两个东西，才可以发生传播。单体不存在传播这个行为。 事务传播行为（propagation behavior）指的就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行。 例如：methodA事务方法调用methodB事务方法时，methodB是继续在调用者methodA的事务中运行呢，还是为自...
事务
kk屯学的博客
12-04 328
/** * 事务传播 - Propagation * REQUIRED: 使用当前的事务，如果当前没有事务，则自己新建一个事务，子方法是必须运行在一个事务中的； * 如果当前存在事务，则加入这个事务，成为一个整体。 * 举例：领导没饭吃，我有钱，我会自己买了自己吃；领导有的吃，会分给你一起吃。 * SUPP...
7种事务传播行为案例详解
拾信
06-18 1124
1.什么是事务传播行为? 指的是当一个事务方法（A）被另一个事务方法（B）调用时候，这个事务方法（A）应该如何运行。 2.事务传播行为有哪些种类? 文字版： 事务传播行为类型 说明 1 PROPAGATION_REQUIRED 如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。这是最常见的选择。 2 PROP..
Spring事务传播行为详解与示例
"Spring中的事务传播行为示例详解" 在Spring框架中，事务传播行为是处理事务管理的关键概念，尤其在多方法协作时显得尤为重要。它定义了在一个事务方法被调用时，如何处理调用者自身所处的事务环境。Spring提供了七...
事务的传播行为
weixin_43133686的博客
12-21 587
一、什么是事务传播行为？ 事务传播行为（propagation behavior）指的就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何运行。 例如：methodA方法调用methodB方法时，methodB是继续在调用者methodA的事务中运行呢，还是为自己开启一个新事务运行，这就是由methodB的事务传播行为决定的。 二、事务的7种传播行为 Spring在TransactionDefinition接口中规定了7种类型的事务传播行为。 事务传播行为是Spring框架独...
Spring事务的 7 种传播行为
qq_45110186的博客
02-11 4965
Spring 框架中的事务传播行为定义了在多个事务操作嵌套执行时，如何处理事务的传播和管理。Spring 提供了多种事务传播行为，以满足不同的业务需求。
Spring事务：事务属性之7种传播行为
weixin_43397326的博客
06-09 277
Spring事务：事务属性之7种传播行为事务传播行为 事务传播行为 什么叫事务传播行为？听起来挺高端的，其实很简单。 即然是传播，那么至少有两个东西，才可以发生传播。单体不存在传播这个行为。 事务传播行为（propagation behavior）指的就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行。 例如：methodA事务方法调用methodB事务方法时，methodB是继续在调用者methodA的事务中运行呢，还是为自己开启一个新事务运行，这就是由methodB的事务传播行为决定的。
Spring中事务传播行为种类
iteye_4734的博客
04-30 135
Spring在TransactionDefinition接口中规定了7种类型的事务传播行为，它们规定了事务方法和事务方法发生嵌套调用时事务如何进行传播： 　　PROPAGATION_REQUIRED 　　如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。这是最常见的选择。 　　PROPAGATION_SUPPORTS 　　支持当前事务，如果当前没有...
Spring事务深入解析：传播行为详解
1. **PROPAGATION_REQUIRED (0)**: 这是默认的事务传播行为，表示如果当前存在一个事务，新的操作会加入到这个事务中；如果没有当前事务，Spring会自动创建一个新的事务。这相当于EJB中的相同名称属性。在支持事务...
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

砖业洋__

你的鼓励是我持续写作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值