Spring @Transactional事务传播行为详解

于 2024-08-07 13:08:11 发布
阅读量399 收藏 10
点赞数 6
分类专栏： Java架构 文章标签： spring java 后端 事务 系统架构 事务传播行为 springboot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38196449/article/details/140967490
版权

 

目录

一、无事务情况

二、有事务情况

REQUIRED

SUPPORTS

MANDATORY

REQUIRES_NEW

NOT_SUPPORTED

NEVER

NESTED

Spring的事务传播机制用于控制在多个事务方法相互调用时事务的行为。

在复杂的业务场景中，多个事务方法之间的调用可能会导致事务的一致性，如出现数据丢失、重复提交等问题，使用事务传播机制可以避免这些问题的发生，保证事务的一致性和完整性。

Spring的事务规定了7种事务的传播级别，默认的传播机制是REQUIRED。

一、无事务情况

我们先看一段代码：

public void testPropagationTrans() {
	stuService.saveParent();
	stuService.saveChildren();
}


public void saveParent() {
	Stu stu = new Stu();
	stu.setName("parent");
	stu.setAge(30);
	stuMapper.insert(stu);
}


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);
}

public void saveChild2() {
	Stu stu2 = new Stu();
	stu2.setName("child-2");
	stu2.setAge(22);
	stuMapper.insert(stu2);
}

当我们运行testPropagationTrans方法，发现数据库是这样的

当saveChildren方法中有异常，也不会做事务回滚，其实也正常，因为我们也没加事务。

二、有事务情况

注：我们为了好理解，把testPropagationTrans叫做父方法，saveParent和saveChildren叫做子方法。

REQUIRED

REQUIRED：如果不存在事务则开启一个事务，如果存在事务则加入之前的事务，总是只有一个事务在执行。

举例：领导没饭吃，我有钱，我会自己买了自己吃；领导有的吃，会分给你一起吃。

比如我们代码如下；

public void testPropagationTrans() {
	stuService.saveParent();
	stuService.saveChildren();
}

public void saveParent() {
	Stu stu = new Stu();
	stu.setName("parent");
	stu.setAge(30);
	stuMapper.insert(stu);
}

@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);
}

public void saveChild2() {
	Stu stu2 = new Stu();
	stu2.setName("child-2");
	stu2.setAge(22);
	stuMapper.insert(stu2);
}

这样的结果很好理解，我在子方法有事务，当然只管我自己的回滚，并不管其它的，正所谓我有钱我自己买饭吃，别人我不管。

但是当你把@Transactional(propagation = Propagation.REQUIRED)放在父方法上，那么数据库里将会什么数据都没有，因为父方法有事务，子方法会加入此事务，相当于都包在里面了，所以有异常则全部回滚。

SUPPORTS

SUPPORTS：有事务则加入事务，没有事务则普通执行。

举例：领导没饭吃，我也没饭吃；领导有饭吃，我也有饭吃。

public void testPropagationTrans() {
	stuService.saveParent();
	stuService.saveChildren();
}

public void saveParent() {
	Stu stu = new Stu();
	stu.setName("parent");
	stu.setAge(30);
	stuMapper.insert(stu);
}

@Transactional(propagation = Propagation.SUPPORTS)
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);
}

public void saveChild2() {
	Stu stu2 = new Stu();
	stu2.setName("child-2");
	stu2.setAge(22);
	stuMapper.insert(stu2);
}

很明显，如果父方法没有事务，那就相当于都没事务，就正常运行了。

但如果父方法有@Transactional(propagation = Propagation.REQUIRED)注解，则加入父方法事务。

MANDATORY

MANDATORY：强制有事务，没有事务则报异常。

举例：领导必须管饭，不管饭我就抛出异常。

public void testPropagationTrans() {
	stuService.saveParent();
	stuService.saveChildren();
}

public void saveParent() {
	Stu stu = new Stu();
	stu.setName("parent");
	stu.setAge(30);
	stuMapper.insert(stu);
}

@Transactional(propagation = Propagation.MANDATORY)
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);
}

public void saveChild2() {
	Stu stu2 = new Stu();
	stu2.setName("child-2");
	stu2.setAge(22);
	stuMapper.insert(stu2);
}

这样系统直接抛出异常，因为父方法没有事务。

REQUIRES_NEW

REQUIRES_NEW：每次执行新开一个事务，如果当前存在事务，则把当前事务挂起。

举例：领导管饭，但我偏不要，我自己买了自己吃，如果领导不管饭，我自己也有钱买饭。

public void testPropagationTrans() {
	stuService.saveParent();
	stuService.saveChildren();
}

public void saveParent() {
	Stu stu = new Stu();
	stu.setName("parent");
	stu.setAge(30);
	stuMapper.insert(stu);
}

@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);
}

public void saveChild2() {
	Stu stu2 = new Stu();
	stu2.setName("child-2");
	stu2.setAge(22);
	stuMapper.insert(stu2);
}

结果说明，子方法自己创建了一个新的事务自己用。

如果我父方法上加了事务，这时数据库会发现什么数据都没有。

但我们再考虑一种情况，代码如下：

@Transactional(propagation = Propagation.REQUIRES)
public void testPropagationTrans() {
	stuService.saveParent();
	stuService.saveChildren();
	int a = 1 / 0;
}

public void saveParent() {
	Stu stu = new Stu();
	stu.setName("parent");
	stu.setAge(30);
	stuMapper.insert(stu);
}

@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);
}

public void saveChild2() {
	Stu stu2 = new Stu();
	stu2.setName("child-2");
	stu2.setAge(22);
	stuMapper.insert(stu2);
}

我们把异常代码放在父方法中，这时数据库结果发现：

这个结果是如何造成的呢？

其实当执行代码时，子方法创建了一个新的事务，并把父方法的事务挂起，所以也就是说，子事务是子事务，父事务是父事务，这是两个事务。

所以当父方法有异常时，直接回滚saveParent方法，并不影响子事务的操作。

NOT_SUPPORTED

NOT_SUPPORTED：如果当前有事务，则把事务挂起，自己不使用事务去运行数据库操作。

举例：领导管饭，分一点给你，但你太忙了，放一边不吃。

public void testPropagationTrans() {
	stuService.saveParent();
	stuService.saveChildren();
}

public void saveParent() {
	Stu stu = new Stu();
	stu.setName("parent");
	stu.setAge(30);
	stuMapper.insert(stu);
}

@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);
}

public void saveChild2() {
	Stu stu2 = new Stu();
	stu2.setName("child-2");
	stu2.setAge(22);
	stuMapper.insert(stu2);
}

看的出来，压根没使用事务。

当我在父方法上加上事务。

@Transactional(propagation = Propagation.REQUIRES)
public void testPropagationTrans() {
	stuService.saveParent();
	stuService.saveChildren();
}

public void saveParent() {
	Stu stu = new Stu();
	stu.setName("parent");
	stu.setAge(30);
	stuMapper.insert(stu);
}

@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);
}

public void saveChild2() {
	Stu stu2 = new Stu();
	stu2.setName("child-2");
	stu2.setAge(22);
	stuMapper.insert(stu2);
}

这个结果说明子方法没有事务，而且还把父事务挂起，所以父有事务，导致saveParent方法可以回滚。

NEVER

NEVER：如果当前有事务存在，则抛出异常。

举例：领导管饭，我不想吃，我抛出异常。

@Transactional(propagation = Propagation.REQUIRES)
public void testPropagationTrans() {
	stuService.saveParent();
	stuService.saveChildren();
}

public void saveParent() {
	Stu stu = new Stu();
	stu.setName("parent");
	stu.setAge(30);
	stuMapper.insert(stu);
}

@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);
}

public void saveChild2() {
	Stu stu2 = new Stu();
	stu2.setName("child-2");
	stu2.setAge(22);
	stuMapper.insert(stu2);
}

代码直接报错异常，因为never不允许你（父）有事务。

NESTED

NESTED：如果当前有事务，则开启子事务（嵌套事务），嵌套事务是独立提交或者回滚；如果当前没有事务，则同REQUIRED。但是如果主事务提交，则会携带子事务一起提交。

如果主事务回滚，则子事务一起回滚，相反，子事务异常，则父事务可以回滚或不回滚。

举例：领导决策不对，老板怪罪，领导带着小弟一同受罪。小弟出了差错，领导可以推卸责任，也可以承担责任。

@Transactional(propagation = Propagation.REQUIRES)
public void testPropagationTrans() {
	stuService.saveParent();
	stuService.saveChildren();
	int a = 1 / 0;
}

public void saveParent() {
	Stu stu = new Stu();
	stu.setName("parent");
	stu.setAge(30);
	stuMapper.insert(stu);
}

@Transactional(propagation = Propagation.NESTED)
public void saveChildren() {
	saveChild1();
	saveChild2();
}

public void saveChild1() {
	Stu stu1 = new Stu();
	stu1.setName("child-1");
	stu1.setAge(11);
	stuMapper.insert(stu1);
}

public void saveChild2() {
	Stu stu2 = new Stu();
	stu2.setName("child-2");
	stu2.setAge(22);
	stuMapper.insert(stu2);
}

结果数据库什么数据都没有。因为父有事务，当父方法有异常，里面的嵌套事务要被回滚。

但如果子事务发生异常呢？

@Transactional(propagation = Propagation.REQUIRES)
public void testPropagationTrans() {
	stuService.saveParent();
	stuService.saveChildren();
}

public void saveParent() {
	Stu stu = new Stu();
	stu.setName("parent");
	stu.setAge(30);
	stuMapper.insert(stu);
}

@Transactional(propagation = Propagation.NESTED)
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);
}

public void saveChild2() {
	Stu stu2 = new Stu();
	stu2.setName("child-2");
	stu2.setAge(22);
	stuMapper.insert(stu2);
}

结果数据库还是什么数据都没有，这是因为子事务的异常会影响到父方法。但这个是可选的，我们可以给父方法调用加异常，这样就不会影响父方法事务了，如下：

@Transactional(propagation = Propagation.REQUIRES)
public void testPropagationTrans() {
	stuService.saveParent();
	try {
		stuService.saveChildren();
	}catch (Exception e) {
		e.printStackTrace();
	}
}
神农尝百码
关注
  • 6
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Spring @Transactional事务传播机制详解
endwas
04-09 3667
## 总结 本文讲解了Spring事务的七种传播机制，我们可以根据具体的类型，具体设置，避免事务的方法过于长，一个事务里面调用的库表越多，就越有可能造成死锁，所以我们要根据具体的需要拆分使用。
Spring事务：@Transactional注解详解
资料免费分享，点击名片
08-05 2129
背景前两天在工作中忙的焦头烂额，涉及到 @Transactional 对于事务的控制，便仔细研究了一下，颇有所获，花费好了几天测试整理，今天才发表出来，希望老铁们能有所获吧。Spring 事务的传播行为话不多说直奔正题。先简单介绍一下 Spring 事务的传播行为。所谓事务的传播行为是指，如果在开始当前事务之前，一个事务上下文已经存在，此时有若干选项可以指定一个事务性方法的执行行为。在 TransactionDefinition 定义中包括了如下几个表示传播行为的常量：TransactionDefiniti
关于Spring @Transactional事务传播机制详解
weixin_42023748的博客
01-02 1519
举个栗子，方法A是一个事务的方法，方法A执行过程中调用了方法B，那么方法B有无事务以及方法B对事务的要求不同都会对方法A的事务具体执行造成影响，同时方法A的事务对方法B的事务执行也有影响，这种影响具体是什么就由两个方法所定义的事务传播类型所决定。简单说就是，我们方法调用通常是，一个方法调用另外一个，而不同方法可以有不同的事务，所以传播机制就是指在多个方法，事务要如何传播。一共有七种传播类型本文从案例结合解释一下不同传播类型下多个@Transactional方法会发生什么？
【Spring】@Transactional事务属性详解
hhb442的博客
12-13 632
注解开启事务，其中注解的各种属性详解。
Spring中@Transactional注解事务传播行为propagation参数说明
Java全栈开发者
06-28 778
在SpringBoot项目中，我们通常使用去进行事务控制，而注解中，有个比较关键的属性就是。在一个的环境中，一个事务方法调用另一个事务方法时，就会涉及到事务的传播行为，该属性用来控制一段代码经过多个注解生效（同一个类的不同方法调用是不会生效的）的方法的事务传播机制。由源码可知，他是用来指定的，在不指定的情况下，默认值为。而查看可知，一共有以下7个属性。
Spring——事务注解@Transactional【建议收藏】
娜娜米的博客
07-18 3万+
在某些业务场景下，如果一个请求中，需要同时写入多张表的数据或者执行多条sql，为了保证操作的原子性（要么同时成功，要么同时失败），避免数据不一致的情况，我们一般都会用到事务；Spring框架下，我们经常会使用@Transactional注解来管理事务； 本篇介绍Spring的事务注解@Transactional相关的知识，包括事务简介、事务隔离级别、Spring声明式事务实现原理、事务的传播行为、@Transactional的用法及注意事项等，属于Spring的常用注解之一，需要掌握相关知识点；...
Spring声明式事务@Transactional 详解，事务隔离级别和传播行为
qq_45441466的博客
03-20 2212
@Transactional注解支持9个属性的设置，这里只讲解其中使用较多的三个属性：readOnly、propagation、isolation。其中propagation属性用来枚举事务的传播行为，isolation用来设置事务隔离级别，readOnly进行读写事务控制。 一、readOnly读写事务控制 readOnly=true表明所注解的方法或类只是读取数据。 readOnly=false表明所注解的方法或类是增加，删除，修改数据。 二、isolation事务隔离级别 详细博文可参考：h
Spring中注解事务@Transactional用法详解
qq_32512453的博客
04-14 815
1，常用参数说明 ： 参数名称 功能描述 readOnly 该属性用于设置当前事务是否为只读事务，设置为true表示只读，false则表示可读写，默认值为false。例如：@Transactional(readOnly=true) rollbackFor 该属性用于设置需要进行回滚的异常类数组，当方法中抛出指定异常数组中的异常时，则进行事务回滚。例如:指定单一异常类：@Transactional(rollbackFor=RuntimeException.class) ； 指定多个异
@Transactional 详解
热门推荐
愿我如星君如月 ... 夜夜流光相皎洁 ...
11-23 46万+
@Transactional 是声明式事务管理 编程中使用的注解 1 .添加位置 1）接口实现类或接口实现方法上，而不是接口类中。 2）访问权限：public 的方法才起作用。@Transactional 注解应该只被应用到 public 方法上，这是由 Spring AOP 的本质决定的。 系统设计：将标签放置在需要进行事务管理的方法上，而不是放在所有接口实现类上：只读的接口就不需要事务管...
Spring @Transactional工作原理详解
08-28
事务的传播行为（propagation）是`@Transactional`的另一个重要特性。它定义了当一个事务方法被另一个事务方法调用时，如何处理新的事务。例如，PROPAGATION_REQUIRED是默认设置，表示如果当前存在事务，则加入该...
Spring中@Transactional用法详细介绍
08-31
1. **事务传播行为（Propagation）**： - `Propagation.REQUIRED`：默认值，如果当前存在事务，则加入该事务；如果不存在，则创建一个新的事务。 - `Propagation.SUPPORTS`：如果当前存在事务，则加入该事务；如果...
Spring 事务隔离与事务传播的详解与对比
10-19
总的来说，Spring的事务隔离和事务传播机制提供了强大的工具来管理应用程序的事务行为，确保数据一致性。开发者可以根据业务需求和性能考虑选择适当的事务策略。在实际应用中，应充分理解并灵活运用这些概念，以达到...
深入理解Spring的事务传播行为
08-27
【Spring的事务传播行为详解】 在Spring框架中，事务传播行为是其事务管理的一大特色，它定义了在多个具有事务控制的服务之间相互调用时如何处理事务边界。这有助于解决在分布式系统中复杂的事务管理问题。Spring...
Spring中事务的传播属性详解
03-11
本文将详细介绍Spring中的事务传播属性，并通过具体的例子来解释每种传播行为的特点。 #### 二、事务传播属性概述 事务传播行为（Propagation）定义了当一个事务方法被另一个事务方法调用时的行为。在Spring中，...
SpringBoot3 配置Logback日志滚动文件
cm777的博客
08-06 525
本文介绍了在SpringBoot3中配置Logback日志滚动文件的方法，因为SpringBoot3内置的logback版本是1.4.14，之前使用SpringBoot2.1.5的logback配置发现有些东西不能生效了。
基于 SpringBoot 和 VUE 的智慧食堂系统
FireFox1997
08-06 545
本文主要是针对线下传统管理方式中管理不便与效率低的缺点，将电子商务和计算机技术结合起来，开发出管理便捷，效率高的“智慧食堂”系统。本系统能够提供管理员在线管理，管理首页，个人中心，用户管理，菜品分类管理，菜品信息管理，留言板管理，系统管理，订单管理等功能。4、主页内容管理：管理员登录以后，可以对首页，个人中心，用户管理，菜品分类管理，菜品信息管理，留言板管理，系统管理，订单管理进行详细操作。2、新用户注册：新用户填写用户账号，用户姓名，密码，确认密码，联系方式等信息，完成注册。
SpringCloud入门简介
最新发布
敢问路在何方，路在脚下
08-06 249
SpringCloud是微服务治理方案之一；SpringCloud与SSM框架和SpringBoot没什么关联SSM：web应用的开发框架，包含视图层（模型model+视图view+控制器controller），业务层，持久层SpringBoot：简化SSM的配置，同时提供构建项目的脚手架。
Java之SpringBoot入门(含Spring Mvc)
qq_35639854的博客
08-06 703
在计算机领域, 会话是⼀个客⼾与服务器之间的不中断的请求响应. 对客⼾的每个请求，服务器能够识 别出请求来⾃于同⼀个客⼾. 当⼀个未知的客⼾向Web应⽤程序发送第⼀个请求时就开始了⼀个会话. 当客⼾明确结束会话或服务器在⼀个时限内没有接受到客⼾的任何请求时，会话就结束了.服务器同⼀时刻收到的请求是很多的. 服务器需要清楚的区分每个请求是从属于哪个⽤⼾, 也就是属于 哪个会话, 就需要在服务器这边记录每个会话以及与⽤⼾的信息的对应关系. Session是服务器为了保存⽤⼾信息⽽创建的⼀个特殊的对象.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

神农尝百码

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值