搞懂Spring的事务传播机制

最新推荐文章于 2024-08-11 09:26:38 发布
最新推荐文章于 2024-08-11 09:26:38 发布
阅读量263 收藏 2
点赞数 1
分类专栏： spring 文章标签： spring Spring的事务传播机制
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_17555933/article/details/116108558
版权

搞懂Spring的事务传播机制

事务传播枚举：
org.springframework.transaction.annotation.Propagation
REQUIRED(0),
SUPPORTS(1),
MANDATORY(2),
REQUIRES_NEW(3),
NOT_SUPPORTED(4),
NEVER(5),
NESTED(6);

@Transactional(propagation= Propagation.REQUIRED)

结论：

  使用当前的事务，如果当前没有事务，则自己新建一个事务，子方法是必须运行在一个事务中的；

如果当前存在事务，则加入这个事务，成为一个整体。

举例：

  老爸没钱吃饭，儿子有钱，儿子会自己买了自己吃【哈哈，很自私】。老爸有钱吃饭，会分吃的给儿子【这叫父爱】。

实验一：
com.golder.test.TransactionTest#userTransactionTest
@Test
public void userTransactionTest() {
    transactionService.testPropagationTrans();
}
com.golder.service.impl.TransactionServiceImpl#testPropagationTrans：
@Override
public void testPropagationTrans() {
    usersService.saveParent();
    usersService.saveChildren();
}
com.golder.service.impl.UsersServiceImpl#saveChildren：
@Override
public void saveParent() {
    Users users = new Users();
    users.setId("4");
    users.setUsername("saveParent");
    users.setPassword("123");
    users.setFace("saveParent");
    users.setCreatedTime(new Date());
    users.setUpdatedTime(new Date());
    usersMapper.insert(users);
}

@Override
public void saveChildren() {
    saveChildren1();
    int a = 1 / 0;
    saveChildren2();
}

public void saveChildren1() {
    Users users = new Users();
    users.setId("5");
    users.setUsername("saveChildren-1");
    users.setPassword("123");
    users.setFace("saveChildren");
    users.setCreatedTime(new Date());
    users.setUpdatedTime(new Date());
    usersMapper.insert(users);
}
public void saveChildren2() {
    Users users = new Users();
    users.setId("7");
    users.setUsername("saveChildren-2");
    users.setPassword("123");
    users.setFace("saveChildren-2");
    users.setCreatedTime(new Date());
    users.setUpdatedTime(new Date());
    usersMapper.insert(users);
}
分析：

  以上这种情况，saveParent()和saveChildren()#saveChildren1()会成功保存数据，saveChildren2()不会被执行。也就是说，没有事务注解@Transactional时，程序不会自动回滚事务。

实验二：

  给TransactionServiceImpl#testPropagationTrans()添加事务注解@Transactional(propagation= Propagation.REQUIRED)

com.golder.service.impl.TransactionServiceImpl#testPropagationTrans：
@Transactional(propagation= Propagation.REQUIRED)
@Override
public void testPropagationTrans() {
    usersService.saveParent();
    usersService.saveChildren();
}
分析：

  以上这种情况，saveParent()和saveChildren()#saveChildren1()数据会被回滚。

实验三：

  其他地方不加事务注解，给UsersServiceImpl#saveChildren添加事务注解@Transactional(propagation= Propagation.REQUIRED)

com.golder.service.impl.TransactionServiceImpl#testPropagationTrans：
@Override
public void testPropagationTrans() {
    usersService.saveParent();
    usersService.saveChildren();
}
com.golder.service.impl.UsersServiceImpl#saveChildren：
@Transactional(propagation= Propagation.REQUIRED)
@Override
public void saveChildren() {
    saveChildren1();
    int a = 1 / 0;
    saveChildren2();
}
分析：

  以上这种情况，usersService.saveParent()不会被回滚，而saveChildren()#saveChildren1()会被回滚

@Transactional(propagation = Propagation.SUPPORTS)

结论：

  如果当前有事务，则使用事务；如果当前没有事务，则不使用事务。

举例：

  老爸没饭吃，儿子也没饭吃；老爸有饭吃，我也有饭吃。【同甘共苦】

实验一：
com.golder.service.impl.TransactionServiceImpl#testPropagationTrans：
@Override
public void testPropagationTrans() {
    usersService.saveParent();
    usersService.saveChildren();
}
com.golder.service.impl.UsersServiceImpl#saveChildren：
@Transactional(propagation = Propagation.SUPPORTS)
@Override
public void saveChildren() {
    saveChildren1();
    int a = 1 / 0;
    saveChildren2();
}
分析：

  saveParent()和saveChildren1()数据不会被回滚

实验二：
com.golder.service.impl.TransactionServiceImpl#testPropagationTrans：
@Transactional(propagation= Propagation.REQUIRED)
@Override
public void testPropagationTrans() {
    usersService.saveParent();
    usersService.saveChildren();
}
com.golder.service.impl.UsersServiceImpl#saveChildren：
@Transactional(propagation = Propagation.SUPPORTS)
@Override
public void saveChildren() {
    saveChildren1();
    int a = 1 / 0;
    saveChildren2();
}
分析：

  saveParent()和saveChildren1()数据会被回滚

@Transactional(propagation = Propagation.MANDATORY)

结论：

  该传播属性强制必须存在一个事务，如果不存在，则抛出异常。

举例：

  老爸叫儿子买包烟，儿子说给跑腿费【事务】我就去，否则我不去。【前提是要有事务，否则抛个异常给你】

实验一：
com.golder.service.impl.TransactionServiceImpl#testPropagationTrans：
@Override
public void testPropagationTrans() {
    usersService.saveParent();
    usersService.saveChildren();
}
com.golder.service.impl.UsersServiceImpl#saveChildren：
@Transactional(propagation = Propagation.MANDATORY)
@Override
public void saveChildren() {
    saveChildren1();
    int a = 1 / 0;
    saveChildren2();
}
分析：

  通过这个@Transactional(propagation = Propagation.MANDATORY)的源码可以知道【源码注释：Support a current transaction, throw an exception if none exists】，如果调用方没有事务，则会抛出异常(org.springframework.transaction.IllegalTransactionStateException: No existing transaction found for transaction marked with propagation 'mandatory')。

实验二：
com.golder.service.impl.TransactionServiceImpl#testPropagationTrans：
@Transactional(propagation= Propagation.REQUIRED)
@Override
public void testPropagationTrans() {
    usersService.saveParent();
    usersService.saveChildren();
}
com.golder.service.impl.UsersServiceImpl#saveChildren：
@Transactional(propagation = Propagation.MANDATORY)
@Override
public void saveChildren() {
    saveChildren1();
    int a = 1 / 0;
    saveChildren2();
}
分析：

  程序运行正常。但是，saveParent()和saveChildren1()数据会被回滚

@Transactional(propagation = Propagation.REQUIRES_NEW)

结论：

  如果当前有事务，则挂起该事务，并且自己创建一个新的事务给自己使用；如果当前没有，则创建一个同Propagation.REQUIRES一样的事务。

举例：

  老爸请儿子吃饭，儿子偏不要，老子有钱，为什么要你请？老子有钱吃饭。

实验一：
com.golder.service.impl.TransactionServiceImpl#testPropagationTrans：
@Override
public void testPropagationTrans() {
    usersService.saveParent();
    usersService.saveChildren();
}
com.golder.service.impl.UsersServiceImpl#saveChildren：
@Transactional(propagation = Propagation.REQUIRES_NEW)
@Override
public void saveChildren() {
    saveChildren1();
    int a = 1 / 0;
    saveChildren2();
}
分析：

  saveParent()不会被回滚，saveChildren1()会被回滚，因为saveChildren()会新开一个事务。

实验二：
com.golder.service.impl.TransactionServiceImpl#testPropagationTrans：
@Transactional(propagation= Propagation.REQUIRED)
@Override
public void testPropagationTrans() {
    usersService.saveParent();
    usersService.saveChildren();
}
com.golder.service.impl.UsersServiceImpl#saveChildren：
@Transactional(propagation = Propagation.REQUIRES_NEW)
@Override
public void saveChildren() {
    saveChildren1();
    int a = 1 / 0;
    saveChildren2();
}
分析：

  saveParent()和saveChildren1()数据会被回滚。但是，saveChildren()会挂起上面传播下来的事务，自己创建了一个事务。

实验三：
com.golder.service.impl.TransactionServiceImpl#testPropagationTrans：
@Transactional(propagation= Propagation.REQUIRED)
@Override
public void testPropagationTrans() {
    usersService.saveParent();
    usersService.saveChildren();
    int a = 1 / 0;
}
com.golder.service.impl.UsersServiceImpl#saveChildren：
@Transactional(propagation = Propagation.REQUIRES_NEW)
@Override
public void saveChildren() {
    saveChildren1();
    saveChildren2();
}
分析：

  saveParent()数据会被回滚，但是，saveChildren()中saveChildren1()、saveChildren2()数据不会被回滚，因为saveChildren()是独立的新事务。

@Transactional(propagation = Propagation.NOT_SUPPORTED)

结论：

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

举例：

  老爸有钱吃饭，分点给儿子，儿子不鸟老爸，把钱放一边，这点钱能吃啥，不吃。

实验一：
com.golder.service.impl.TransactionServiceImpl#testPropagationTrans：
@Override
public void testPropagationTrans() {
    usersService.saveParent();
    usersService.saveChildren();
}
com.golder.service.impl.UsersServiceImpl#saveChildren：
@Transactional(propagation = Propagation.NOT_SUPPORTED)
@Override
public void saveChildren() {
    saveChildren1();
    int a = 1 / 0;
    saveChildren2();
}
分析：

  saveParent()和saveChildren1()数据不会被回滚

实验二：
com.golder.service.impl.TransactionServiceImpl#testPropagationTrans：
@Transactional(propagation= Propagation.REQUIRED)
@Override
public void testPropagationTrans() {
    usersService.saveParent();
    usersService.saveChildren();
}
com.golder.service.impl.UsersServiceImpl#saveChildren：
@Transactional(propagation = Propagation.NOT_SUPPORTED)
@Override
public void saveChildren() {
    saveChildren1();
    int a = 1 / 0;
    saveChildren2();
}
分析：

  saveParent()数据会被回滚，saveChildren1()数据不会回滚，因为Propagation.NOT_SUPPORTED表示该方法不回滚事务。

@Transactional(propagation = Propagation.NEVER)

结论：

  顾名思义，never是从不的意思，即从不使用事务。如果当前有事务，则抛出异常。

举例：

  老爸叫儿子买烟，给一个亿的跑腿费，儿子在上分打游戏没空，不鸟他，抛个异常给他。

实验一：
com.golder.service.impl.TransactionServiceImpl#testPropagationTrans：
@Transactional(propagation= Propagation.REQUIRED)
@Override
public void testPropagationTrans() {
    usersService.saveParent();
    usersService.saveChildren();
}
com.golder.service.impl.UsersServiceImpl#saveChildren：
@Transactional(propagation = Propagation.NEVER)
@Override
public void saveChildren() {
    saveChildren1();
    int a = 1 / 0;
    saveChildren2();
}
分析：

  直接抛异常（org.springframework.transaction.IllegalTransactionStateException: Existing transaction found for transaction marked with propagation 'never'），这个方法saveChildren()被标记为never，调用方不能使用事务，否则就抛异常。

实验二：
com.golder.service.impl.TransactionServiceImpl#testPropagationTrans：
@Override
public void testPropagationTrans() {
    usersService.saveParent();
    usersService.saveChildren();
}
com.golder.service.impl.UsersServiceImpl#saveChildren：
@Transactional(propagation = Propagation.NEVER)
@Override
public void saveChildren() {
    saveChildren1();
    int a = 1 / 0;
    saveChildren2();
}
分析：

  saveParent()和saveChildren1()数据不会被回滚，道理你们都懂。

@Transactional(propagation = Propagation.NESTED)

结论：

  如果当前有事务，则开启子事务（嵌套事务），嵌套事务是独立提交或者回滚；

如果当前没有事务，则开启同Propagation.REQUIRED一样的事务。

但是如果父事务提交，则会携带子事务一起提交。

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

举例：

  老爸带儿子出去斗地主，把钱都输光了，怕被老婆知道，让儿子一起背锅。老爸拿钱给儿子去赌一把，把钱输光了，就把责任推给儿子，让儿子一个人背锅。【老子犯错让儿子一起背锅，儿子犯错，儿子自己背锅，老子看心情理你】

实验一：
com.golder.service.impl.TransactionServiceImpl#testPropagationTrans：
@Override
public void testPropagationTrans() {
    usersService.saveParent();
    usersService.saveChildren();
}
com.golder.service.impl.UsersServiceImpl#saveChildren：
@Transactional(propagation = Propagation.NEVER)
@Override
public void saveChildren() {
    saveChildren1();
    int a = 1 / 0;
    saveChildren2();
}
分析：

  saveParent()数据不会被回滚，saveChildren1()数据会被回滚，因为Propagation.NEVER会开启一个同Propagation.REQUEST一样的事务。

实验二：
com.golder.service.impl.TransactionServiceImpl#testPropagationTrans：
@Transactional(propagation= Propagation.REQUIRED)
@Override
public void testPropagationTrans() {
    usersService.saveParent();
    usersService.saveChildren();
}
com.golder.service.impl.UsersServiceImpl#saveChildren：
@Transactional(propagation = Propagation.NEVER)
@Override
public void saveChildren() {
    saveChildren1();
    int a = 1 / 0;
    saveChildren2();
}
分析：

  saveParent()和saveChildren1()数据都会被回滚，因为Propagation.NEVER会开启一个嵌套事务，是Propagation.REQUIRED的子事务，父事务可以选择不回滚当前事务，也可以选择回滚当前事务。但是，当父事务提交时，子事务也会一起提交。

总结：
1. @Transactional(propagation= Propagation.REQUIRED)
使用当前的事务，如果当前没有事务，则自己新建一个事务，子方法是必须运行在一个事务中的；
如果当前存在事务，则加入这个事务，成为一个整体。
2. @Transactional(propagation = Propagation.SUPPORTS)
如果当前有事务，则使用事务；如果当前没有事务，则不使用事务。
3. @Transactional(propagation = Propagation.MANDATORY)
该传播属性强制必须存在一个事务，如果不存在，则抛出异常。
4. @Transactional(propagation = Propagation.REQUIRES_NEW)
如果当前有事务，则挂起该事务，并且自己创建一个新的事务给自己使用；如果当前没有，则创建一个同Propagation.REQUIRES一样的事务。
5. @Transactional(propagation = Propagation.NOT_SUPPORTED)
如果当前有事务，则把事务挂起，自己不使用事务去运行数据库操作
6. @Transactional(propagation = Propagation.NEVER)
顾名思义，never是从不的意思，即从不使用事务。如果当前有事务，则抛出异常。
7. @Transactional(propagation = Propagation.NESTED)
如果当前有事务，则开启子事务（嵌套事务），嵌套事务是独立提交或者回滚；

如果当前没有事务，则开启同Propagation.REQUIRED一样的事务。

但是如果父事务提交，则会携带子事务一起提交。

如果父事务回滚，则子事务会一起回滚。相反，子事务异常，则父事务可以回滚或不回滚。
雨润泽林
关注
专栏目录
Spring事务传播机制.docx
01-13
Spring 事务传播机制 Spring 事务传播机制是指在 Spring 框架中，事务的传播和嵌套机制。当我们在使用 Spring 所提供的事务功能时，如果是仅仅处理单个的事务，是比较容易把握事务的提交与回滚，不过一旦引入嵌套...
程序包org.springframework.transaction.annotation不存在
猫头虎：授渔优于赠鱼，兴趣引领智慧，探索之乐尤显珍贵。商务合作：Libin9iOak，共赴知识与乐趣的探索之旅！
04-19 9607
整合ssm报:程序包org.springframework.transaction.annotation不存在 使用注解: @Transactional 之后,就一直报不存在 最终找到原因是:maven依赖 spring-tx版本问题,换个版本就OK 下面展示一下我的依赖包: <dependencies> <!--junit测试--> <dependency> <groupId>junit&
org.springframework.transaction.annotation.Transactional 简单使用示例
老照片
08-10 1378
org.springframework.transaction.annotation.Transactional 简单使用示例及解释
浅谈Spring中的事务及事务传播机制
最新发布
m0_63191002的博客
08-11 1369
Spring事务传播机制定义了：多个包含了事务的方法在相互调用时，事务是如何在这些方法间进行传递的。
Maven手动配置Spring事务
小木鱼的博客
11-08 1446
Maven手动配置Spring事务
Spring框架事务和@Transactional注解属性
faithinmyheart的博客
03-19 336
前言: 该篇博客中用到了一个简单的类似购书的项目，项目中向数据库money表中添加一个人id为aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa钱数10元，向book表中添加两本书，第一类id为a2f39533-659f-42ca-af91-c688a83f6e49，数量为1本，单价为10元，该书库存为1本，第二类id为4c37672a-653c-4cc8-9ab5-ee...
找不到Transactional类 依赖@Transactional的解决办法
乾坤未定，你我皆是黑马
09-17 1万+
看的别人的源代码是这样： import org.springframework.transaction.annotation.Transactional; 但其实对我来说是错误的 应该是： import org.springframework.transaction.annotation.Transactional; 添加的依赖如下： <dependency> ...
spring 事务传播 demo
06-05
本示例“spring 事务传播 demo”将聚焦于Spring的事务传播行为，这是在多个方法调用中控制事务边界的关键概念。下面我们将详细讨论相关知识点。 首先，事务传播行为是指当一个被@Transactional注解的方法被另一个@...
浅谈Spring事务传播行为实战
08-25
二、Spring事务传播机制： 1. REQUIRED：如果当前事务存在，则加入当前事务，如果当前事务不存在，则创建一个新的事务。 2. REQUIRES_NEW：总是创建一个新的事务，如果当前事务存在，则挂起当前事务。 3. SUPPORTS...
Spring事务传播属性和隔离级别详细介绍
08-29
Spring事务传播属性和隔離级别详细介绍 Spring事务传播属性（Propagation）是指在事务中如何...Spring事务传播属性和隔离级别是对事务进行管理和控制的重要机制，可以帮助开发者更好地管理事务，避免各种并发问题。
spring事务传递机制原理
s_156的博客
04-09 840
首先，我们通过org.springframework.transaction.annotation.Propagation来了解一下spring事务的传播定义： 0、REQUIRED（默认）： Support a current transaction, create a new one if none exists. 支持当前事务，如果没有则创建一个新的 1、SUPPORTS Support a current transaction, execute non-transact
配置AOP报错：Error creating bean with name:org.springframework.transaction.annotation.xxxx
莫宇的博客
01-07 1万+
配置aop以及事物出现如下类似错误： Error creating bean with name 'org.springframework.transaction.annotation.AnnotationTransactionAttributeSource#0' 出现原因： 1，spring jar冲突 2，缺少对应jar 解决方案： 1，统一版本号： &lt;propertie...
Spring Data JPA 原理与实战第十一天 JPAS事务、Hibernate和Persistence Context
fegus的博客
05-21 1830
19 如何搞清楚事务、连接池的关系？正确配置是怎样的？ 你好，欢迎继续学习 Spring Data JPA 原理与实战。上一课时，我们讲解了数据源的基本原理和工作方式，你知道了数据源是创建数据连接的入口，数据源里面获得连接的时候也采用了连接池。那么这一讲我们来看下事务在 JPA 和 Spring 里面的详细配置和原理。 事务的基本原理 在学习 Spring 的事务之前，你首先要了解数据库的事务原理，我们以 MySQL 5.7 为例，讲解一下数据库事务的基础知识。 我们都知道 当 MySQL 使用 Inno
Spring使用Spring框架开发银行项目与事务实现相关详解-----Spring框架
春风若有怜花意，可否许我再少年
08-19 203
Spring使用Spring框架开发银行项目与事务实现相关详解-----Spring框架
Spring事务操作-事务引入
LBJ8888888的博客
01-02 638
目录 Spring事务操作-事务引入 1.模拟异常 2.测试异常 3.没有使用spring框架的时候异常该如何处理 4.使用spring框架的时候异常该如何处理 5.在spring 进行声明式事务管理，底层使用AOP 6.spring 事务管理API 7.事务操作（注解声明式事务管理） （1）在spring的配置文件中配置事务管理器 （2）在spring 配置文件中，开启事务注解 （3）在service 类上面（或者service类里面的方法上面） 添加事务注解 （4）@Transa
Spring事务配置（案例：转账业务追加日志，事务传播行为）
阿博的博客
11-22 1071
Spring事务配置（案例：转账业务追加日志，事务传播行为）
@Transctional事务传播机制（Propagation）
zhzh980的博客
04-05 6340
Transactional注解可以作用于接口、接口方法、类以及类方法上。当作用于类上时，该类的所有public方法将都具有该类型的事务属性。当作用在方法级别时，会覆盖类级别的定义。当作用在接口和接口方法时，则只有在使用基于接口的代理时它才会生效，也就是JDK代理。在Spring中，事务的传播类型对方法执行顺序和结果都有影响。调用者和被调用者方法所定义的事务传播类型共同决定了代码的结果。ps.两个问题：Q1:类内部方法调用时，避免@Transcational失效的获取代理类方法待验证。
Spring中事务传播特性（Propagation）
酸奶盖儿的博客
09-03 484
其中定义了事务的传播特性
Spring -- 一个事务中独立开启事务
热门推荐
GP的空间
12-24 1万+
import org.springframework.transaction.annotation.Propagation; import org.springframework.transaction.annotation.Transactional;@Transactional(propagation = Propagation.REQUIRES_NEW, readOnly = false,
Spring事务传播机制解析：TransactionInterceptor的invoke方法
Spring事务传播机制详解 Spring事务是Java EE应用程序中一个非常重要的组件，用于管理数据库事务，以确保数据的一致性和完整性。在Spring框架中，事务是通过AOP（Aspect-Oriented Programming）机制来实现的，这...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

雨润泽林

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

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

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

打赏作者

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

抵扣说明：

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

余额充值