Spring 事务的传播行为

最新推荐文章于 2023-11-30 22:53:20 发布
最新推荐文章于 2023-11-30 22:53:20 发布
阅读量162 收藏 2
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Insect_boy/article/details/110824402
版权

最近复习Spring,看到传播行为这里，有些许疑惑，然后各种百度，返现竟然没有详细的介绍，就几篇比较有质量的文章，没点耐心和基础还看不懂。经过一天多的反复钻研，我把我对传播行为的理解梳理一下。

我们什么时候会用到Spring的传播行为？

在我们使用Spring事务的时候，很有可能遇到一下这种情况在方法A调用方法B，方法B被注解称一个事务，然后这时候方法A要在方法B的基础上做一些操作，这个时候你就要想啊，我要不要把方法A也设置成一个事务呢？方法A种的一下操作想要和方法B保持一致性，有的方法又不想，这时候咋办呢？是不是蒙了？
这个时候就需要使用Spring的事务的传播行为了。

什么是事务的传播行为

什么是事务的传播行为呢，我的理解是当方法A上开启事务了，方法A中调用B这个时候，方法A中的事务能不能到达方法B这一层。

public void  testPropagation(){
        methodA(){
            MethodDoSomethingBefor();
            methodB();
            MethodDoSomethingAfter();
        }
    }
    @Transactional //开启事务
    public void methodB(){
        doSomething();
    }

首先，事务由七种传播行为，我来一一解释下。
在这里插入图片描述
引用人家的图，特此鸣谢
首先要明确一点啊，这其中传播行为倒是配在被调用的方法上的，也就是方法B上，就是说当方法A种需要使用到方法B时，讨论这时候方法A事务是个什么鬼样子（重点）。不要像我一样一开始觉得会有7*7=49种排列组合，只有七种哦(方法A的注解是@Transactional(),方法B是这七种)，这是往后看的前提。

下面结合代码，一个一个的分析：
PROPAGATION_REQUIRED： 表示当前方法必须运行在事务中。如果当前事务存在，方法将会在该事务中运行。否则，会启动一个新的事务。

public void  methodA(){
        customerMapper.insert(new Customer(5l,"我是第一个","你好",0));
        methodB();
    }
    @Transactional //开启事务
    public void methodB(){
        orderMapper.insert(new Order(null ,10l,10l,10l));
        int a =1/0;
    }

在这里插入图片描述
现在是方法A没有开启事务，方法B开启了事务，两者表都是空的，执行方法A
结果：
在这里插入图片描述
结果是都插进去了，所以方法A如果没有开启事务的话，方法B也没法开启。
都开启以后就可以了，看结果rollBack了。
在这里插入图片描述

 public void methodA() {
        customerMapper.insert(new Customer(5l, "我是第一个", "你好", 0));
        methodB();
        int a = 1 / 0;

    }

    @Transactional(propagation = Propagation.REQUIRED) //开启事务
    public void methodB() {
        orderMapper.insert(new Order(null, 10l, 10l, 10l));
//        int a =1/0;

    }

这个是methodA()中有异常，结果（每次重新执行钱都把数据库清空了，也是回滚了
在这里插入图片描述
结论：方法B设置传播行为是PROPAGATION_REQUIRED以后，方法A和方法B整合为一个事务，并且方法A必须开启事务，要不然不会回滚，为什么不会回滚呢，前面提到过，是方法A中的事务能不能到达方法B这一层，如果A不开启事务，则默认是没有开启事务,方法B也得不到传递。

PROPAGATION_SUPPORTS： 表示当前方法不需要事务上下文，但是如果存在当前事务的话，那么该方法会在这个事务中运行
我的理解就是随着方法A,方法A有事务就按事务执行，方法A没有，就不按事务执行。

方法A开启事务，抛异常，没有执行，回滚了

@Transactional()
    public void methodA() {
        customerMapper.insert(new Customer(5l, "我是第一个", "你好", 0));
        methodB();
//        int a = 1 / 0;
        System.out.println("执行了");

    }

    @Transactional(propagation = Propagation.SUPPORTS) //开启事务
    public void methodB() {
        orderMapper.insert(new Order(null, 10l, 10l, 10l));
        int a =1/0;

    }

在这里插入图片描述
方法A关闭事务，插入进去了

//    @Transactional()
    public void methodA() {
        customerMapper.insert(new Customer(5l, "我是第一个", "你好", 0));
        methodB();
//        int a = 1 / 0;
        System.out.println("执行了");

    }

    @Transactional(propagation = Propagation.SUPPORTS) //开启事务
    public void methodB() {
        orderMapper.insert(new Order(null, 10l, 10l, 10l));
        int a =1/0;

    }

在这里插入图片描述
结论，跟随方法A，开启事务，抛异常时数据回滚，不开启事务，可以插入。也符合第一条说的，事务的传播行为时看事务能不能传递到B这一程。

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

public void methodA() {
        customerMapper.insert(new Customer(5l, "我是第一个", "你好", 0));
        bookService.methodB();
//        int a = 1 / 0;
        System.out.println("执行了");
    }
   
   这个方法在bookService中，如果是同一个方法，不会抛异常（所以这也要注意，当使用事务的传播行为的时候，要是两个service）
@Transactional(propagation = Propagation.MANDATORY)
    public void methodB() {
        orderMapper.insert(new Order(null, 10l, 10l, 10l));
//        int a =1/0;
    }

在这里插入图片描述
重点
PROPAGATION_REQUIRED_NEW 表示当前方法必须运行在它自己的事务中。一个新的事务将被启动。如果存在当前事务，在该方法执行期间，当前事务会被挂起。如果使用JTATransactionManager的话，则需要访问TransactionManager

这个表示，在方法A的基础上再建一个事务，相互独立。看代码

 @Transactional
    public void methodA() {
        try{
            customerMapper.insert(new Customer(5l, "我是第一个", "你好", 0));
            bookService.methodB();
        }catch (Exception e){
            customerMapper.insert(new Customer(5l, "我是第二个", "你好", 0));
        }


    }
@Transactional(propagation = Propagation.REQUIRES_NEW)
    public void methodB() {
        orderMapper.insert(new Order(null, 10l, 10l, 10l));
        int a =1/0;
    }

在这里插入图片描述
结果一个插入两条，一个没有插入，是不是很疑惑？我们一点点梳理。
首先介绍一个概念，事务挂起，就是代码事务进去等待状态，等其他的代码执行完，再执行。

再说，PROPAGATION_REQUIRED_NEW，它是不管有没有事务，都重新开启一个事务，或者这样表示

main(){ 
  TransactionManager tm = null; 
try{ 
  //获得一个JTA事务管理器 
    tm = getTransactionManager(); 
    tm.begin();//开启一个新的事务 
    Transaction ts1 = tm.getTransaction(); 
    doSomeThing(); 
    tm.suspend();//挂起当前事务 
    try{ 
      tm.begin();//重新开启第二个事务 
      Transaction ts2 = tm.getTransaction(); 
      methodB(); 
      ts2.commit();//提交第二个事务 
   } 
  Catch(RunTimeException ex){ 
      ts2.rollback();//回滚第二个事务 
  } 
  finally{ 
     //释放资源 
   } 
    //methodB执行完后，复恢第一个事务 
    tm.resume(ts1); 
doSomeThingB(); 
    ts1.commit();//提交第一个事务 
} 
catch(RunTimeException ex){ 
   ts1.rollback();//回滚第一个事务 
} 
finally{ 
   //释放资源 
} 
}

这里引用了别人博客的代码，特此鸣谢
我们都知道，事务的原理就是一个 try{}catch{}finally{}的形式，有异常回滚，没有问题commit,最后释放资源，这里的PROPAGATION_REQUIRED_NEW就是在方法A的try{}catch{}中又做了一层try{}catch{}，这就有可能诞生很多的情况
1）.方法B中有异常，方法B中的操作回滚，不会影响到方法A的操作（前提是方法try{}catch{}了）
2）.方法A中有异常，但是方法B中的操作可以正常进行，因为方法B在自己的事务中commit了已经

@Transactional
    public void methodA() {
        customerMapper.insert(new Customer(5l, "我是第一个", "你好", 0));
        bookService.methodB();
        int a=1/0;
        customerMapper.insert(new Customer(5l, "我是第二个", "你好", 0));

    }
@Transactional(propagation = Propagation.REQUIRES_NEW)
    public void methodB() {
        orderMapper.insert(new Order(null, 10l, 10l, 10l));
    }

在这里插入图片描述
总结 ：PROPAGATION_REQUIRED_NEW 不管有没有都重新开启一个事务

PROPAGATION_NOT_SUPPORTED： 表示该方法不应该运行在事务中。如果存在当前事务，在该方法运行期间，当前事务将被挂起。如果使用JTATransactionManager的话，则需要访问TransactionManager（这里又提到了挂起，也就是说，这里不管你有没有事务，我都执行，并且不影响A的执行）

 @Transactional
    public void methodA() {
        try {
            customerMapper.insert(new Customer(5l, "我是第一个", "你好", 0));
            bookService.methodB();
//        int a=1/0; 
        }catch (Exception e){
            customerMapper.insert(new Customer(5l, "我是第二个", "你好", 0));
        }
    }


@Transactional(propagation = Propagation.NOT_SUPPORTED)
    public void methodB() {
        orderMapper.insert(new Order(null, 10l, 10l, 10l));
        int a =1/0;
    }

在这里插入图片描述

总结： PROPAGATION_NOT_SUPPORTED 不支持事务，有事务就要被挂起**

PROPAGATION_NEVER： 这个和PROPAGATION_MANDATORY正好相反，这个是有事务抛异常

@Transactional
    public void methodA() {
            customerMapper.insert(new Customer(5l, "我是第一个", "你好", 0));
            bookService.methodB();
    }
     @Transactional(propagation = Propagation.NEVER)
    public void methodB() {
        orderMapper.insert(new Order(null, 10l, 10l, 10l));
    }

在这里插入图片描述

PROPAGATION_NESTED： 如果一个活动的事务存在，则运行在一个嵌套的事务中. 如果没有活动事务, 则按TransactionDefinition.PROPAGATION_REQUIRED 属性执行。这是一个嵌套事务,使用JDBC 3.0驱动时,仅仅支持DataSourceTransactionManager作为事务管理器。需要JDBC 驱动的java.sql.Savepoint类。有一些JTA的事务管理器实现可能也提供了同样的功能。使用PROPAGATION_NESTED，还需要把PlatformTransactionManager的nestedTransactionAllowed属性设为true;而 nestedTransactionAllowed属性值默认为false;

是不是很懵，直接上代码逻辑

main(){ 
Connection con = null; 
Savepoint savepoint = null; 
try{ 
   con = getConnection(); 
   con.setAutoCommit(false); 
   doSomeThingA(); 
   savepoint = con.setSavepoint(); 
   try{ 
       methodB(); 
   }catch(RuntimeException ex){ 
      con.rollback(savepoint); 
   } 
   finally{ 
     //释放资源 
  }

   doSomeThingB(); 
   con.commit(); 
} 
catch(RuntimeException ex){ 
  con.rollback(); 
} 
finally{ 
   //释放资源 
} 
}

是不是看着跟REQUIRED_NEW没有区别，不都是在新建一个事务吗，区别就在于上面说的，他是基于JDBC 3.0驱动的，savepoint = con.setSavepoint();，并且在内层少了一个commit这代表什么呢，就是内存出现问题，只会滚内层到savepoint ，外层出现问题全部回滚。

//    @Transactional
    public void methodA() {
        try{
            customerMapper.insert(new Customer(5l, "我是第一个", "你好", 0));
            bookService.methodB();
//            int a=1/0;
        }catch (Exception e){

        }
    }
    
     @Transactional(propagation = Propagation.NESTED)
    public void methodB() {
        orderMapper.insert(new Order(null, 10l, 10l, 10l));
        int a =1/0;
    }

在这里插入图片描述
这里外层没有开启事务，只有内层回滚了，外层执行成功

@Transactional(propagation = Propagation.NESTED)
    public void methodB() {
        orderMapper.insert(new Order(null, 10l, 10l, 10l));
//        int a =1/0;
    }
 @Transactional
    public void methodA() {
        try{
            customerMapper.insert(new Customer(5l, "我是第一个", "你好", 0));
            bookService.methodB();
            int a=1/0;
        }catch (Exception e){

        }
    }

在这里插入图片描述
最后我发现一个问题

 @Transactional
    public void methodA() {
        try{
            customerMapper.insert(new Customer(5l, "我是第一个", "你好", 0));
            bookService.methodB();
            int a=1/0;
        }catch (Exception e){

        }
    }
@Transactional(propagation = Propagation.REQUIRES_NEW)
    public void methodB() {
        orderMapper.insert(new Order(null, 10l, 10l, 10l));
//        int a =1/0;
    }

在这里插入图片描述
当外层有异常的时候，只要try{}catch{}也执行成功了，说明了spring的事务其实就是基于AOP在我们主要代码逻辑上加了获取连接，关闭自动提交，开启事务，catch异常打印异常信息，回滚，最后关闭资源的工作，如果自己try{}catch{}了 那么就不会回滚了
参考：https://www.cnblogs.com/yixianyixian/p/8372832.html

https://www.open-open.com/lib/view/open1350865116821.html

业精于勤_荒于稀
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
浅谈Spring事务传播行为实战
08-25
浅谈Spring事务传播行为实战 Spring框架提供了事务管理的标准实现，通过注解或者XML文件的方式声明和配置事务。事务管理是指按照给定的事务规则来执行事务的提交或者回滚操作。事务的机制实现很大一部依赖事务日志...
Spring 事务传播机制源码浅析——PROPAGATION_REQUIRED 默认传播机制
龚小帅的博客
08-24 5909
事务传播是 Spring 中提出来的概念，很多人使用事务都是在方法上标注注解，然而，如果每个方法上面都标注着注解，那么你应该执行哪个注解的功能呢？所以这里就需要一个机制或者规范来解决这个问题，能够保证所有方法上面的事务能够正常执行(或者说是让事务生效)，这个就是事务的传播机制。你觉得有发生事务传播嘛？
深入理解事务--Spring事务的传播机制
热门推荐
yuanlaishini2010的专栏
05-17 4万+
事务的嵌套概念 所谓事务的嵌套就是两个事务方法之间相互调用。spring事务开启 ，或者是基于接口的或者是基于类的代理被创建（注意一定要是代理，不能手动new 一个对象，并且此类（有无接口都行）一定要被代理——spring中的bean只要纳入了IOC管理都是被代理的）。所以在同一个类中一个方法调用另一个方法有事务的方法，事务是不会起作用的。 ### Spring默认情况下会对运行
SPRING 事务控制
woi123的专栏
06-08 419
在 SPRING 中一共定义了六种事务传播属性 PROPAGATION_REQUIRED -- 支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。 PROPAGATION_SUPPORTS -- 支持当前事务，如果当前没有事务，就以非事务方式执行。 PROPAGATION_MANDATORY -- 支持当前事务，如果当前没有事务，就抛出异常。 PROPAGAT...
知识点归纳(二)
猿人启示录
08-07 427
spring事务的传播属性 spring的传播属性有以下七种： 1、propagation_required:意思是如果存在一个事务，则支持 当前事务，如果没有事务，则开启这个事务。 2、propagation_support:意思是如果存在一个事务就支持当前事务，如果没有事务则不执行事务。 3、propagation_mandatory:如果有事务就执行事务，没有则抛出异常。 4、propag...
Spring事务默认传播行为PROPAGATION_REQUIRED：怎样做到异常被捕获处理后事务还会回滚
Linzhuank的博客
04-29 1268
Spring事务默认传播行为PROPAGATION_REQUIRED：怎样做到异常被捕获处理后事务还会回滚
Spring事务传播行为问题解决
08-25
Spring事务传播行为问题解决 Spring事务传播行为问题解决是指在Spring框架中，事务传播行为的配置和使用问题。事务传播行为是指在多个事务方法之间的调用关系，如何去管理和控制事务的传播和回滚。 一、 Spring...
Spring中事务传播行为的介绍
08-26
Spring 中事务传播行为的介绍 Spring 中事务传播行为是指在分布式事务系统中，事务的边界定义和传播规则。在 Spring 框架中，定义了 7 种不同的传播行为，每种行为都有其特点和应用场景。 1. PROPAGATION_...
spring 事务传播 demo
06-05
本示例“spring 事务传播 demo”将聚焦于Spring的事务传播行为，这是在多个方法调用中控制事务边界的关键概念。下面我们将详细讨论相关知识点。 首先，事务传播行为是指当一个被@Transactional注解的方法被另一个@...
Spring中的事务传播行为示例详解
08-25
Spring中的事务传播行为示例详解 Spring 框架中事务传播行为是指在多个方法之间的调用关系中，如何处理事务的传播和rollback的机制。事务传播行为是 Spring 框架提供的一种事务管理方式，用于控制事务的传播范围和...
Spring声明式事务@Transactional注解详解（事务）
Java后端技术栈
08-30 6762
前面讲过了如何使用使用xml中实现声明式事务，详见博客：Spring5_狂神（IOC，AOP，SpringMybatis，事务）https://blog.csdn.net/weixin_45433031/article/details/115976938 通过xml配置文件很不方便，那么现在我们来学习通过@Transactional注解实现Spring声明式事务 文章目录 一. 使用位置 二. 参数说明 三. 事务传播行为 四. 隔离级别 1. SQL标准规范 .
事务属性之7种传播行为
chuncongyao9948的博客
07-27 129
事务传播行为 什么叫事务传播行为？听起来挺高端的，其实很简单。 即然是传播，那么至少有两个东西，才可以发生传播。单体不存在传播这个行为。 事务传播行为（propagation behavior）指的就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进...
Java千万级数据插入开启事务_每天一道面试题之Spring 事务传播机制--Propagation.REQUIRED...
weixin_39653622的博客
11-22 261
说起spring的事务传播机制，很多人知道，也了解过，但是真正理解的可能真的不多，我们今天就来详细的spring默认的事务传播机制Propagation.REQUIRED，如果其他事务传播机制你似懂非懂或者记不住的话，不要紧，但一定要记住spring默认的事务传播机制因为在大部分的情况下很少有程序员去修改或者设置spring默认的传播机制，如果这个你的搞不懂的话那你开发的东西就很难让领导放心了sp...
Spring事务（三）——传播属性之REQUIRED
奔跑的蜗牛_Kieasr
01-06 3727
事务是与连接对象紧密相关的，事务属性用来控制事务流转。 Spring事务的传播属性有以下几种： PROPAGATION_REQUIRED：如果当前没有事务，就新建一个事务，如果已经存在一个事务中，则加入到这个事务中。默认属性，也是最常使用。 PROPAGATION_NESTED：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与PROPAGATION_REQUIRED类似的操作。 PROPAGATION_REQUIRES_NEW：新建事务，如果当前存在...
spring事务 Propagation.REQUIRES_NEW、Propagation.NESTED、Propagation.REQUIRED使用时候发现的
hepei120的专栏
09-21 3533
Spring事务的传播性与隔离级别     Spring它对JDBC的隔离级别作出了补充和扩展，其提供了7种事务传播行为。     1、PROPAGATION_REQUIRED：默认事务类型，如果没有，就新建一个事务；如果有，就加入当前事务。适合绝大多数情况。     2、PROPAGATION_REQUIRES_NEW：如果没有，就新建一个事务；如果有，就将当前事务挂起。     3、PROPA...
【Spring学习34】Spring事务(4)：事务属性之7种传播行为
程序老兵的博客
04-20 1万+
事务传播行为什么叫事务传播行为？听起来挺高端的，其实很简单。 即然是传播，那么至少有两个东西，才可以发生传播。单体不存在传播这个行为。事务传播行为（propagation behavior）指的就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行。 例如：methodA事务方法调用methodB事务方法时，methodB是继续在调用者methodA的事务中运行呢，还是为自己开启一个
事务传播行为----PROPAGATION_REQUIRED
qq_36816062的博客
08-25 1827
事务传播行为----PROPAGATION_REQUIRED SpringBoot整合Mybatis，Sql语句的执行情况没有打日志，所以增加了如下配置： logback-spring.xml <!--myibatis log configure--> <logger name="com.apache.ibatis" level="DEBUG"/> <logger name="java.sql.Connection" level="DEBUG"/>
spring框架的事务传播级别经典篇
最新发布
健康平安的活着的专栏
11-30 1942
方法A:外围方法，方法B：内部方法，在A中调用B1.事务级别PROPAGATION_REQUIRED：如果A为PROPAGATION_REQUIRED：B 不管有没有设置事务级别，都会加入到A的事务级别中。如果执行B的时候出异常，那么不仅B方法里执行的会被回滚，A也会全回滚。所有Propagation.REQUIRED修饰的内部方法和外围方法均属于同一事务，只要一个方法回滚，整个事务均回滚。
Springboot 跟着我了解下 事务 @Transactional 默认方式 Propagation.REQUIRED
默默不代表沉默
07-10 2万+
在平常的项目里面，最常看到的就是使用注解@Transactional 去操作事务。 如果稍微对spring事物有过了解的，会知道关于事物传播机制，存在6种， 也就是： 同样可以在注解@Transactional里面看到， 默认配置了的是Propagation.REQUIRED （文章的主角） 而在这里也是其实告诉咱们，就算使用注解也是可以指定不同的事物机制： 为什么该篇文章，6种，我只介绍一种呢？而且是介绍的是PROPAGATION_REQUIRED 呢？...
Spring事务传播行为
08-11
以下是一些常见的Spring事务传播行为： 1. REQUIRED（默认）：如果当前存在事务，则加入该事务；如果没有事务，则创建一个新的事务。这是最常用的传播行为，适合大多数情况。 2. SUPPORTS：如果当前存在事务，则...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值