Spring事务传播机制示例验证

最新推荐文章于 2025-02-25 10:29:50 发布
最新推荐文章于 2025-02-25 10:29:50 发布
阅读量743 收藏 20
点赞数 19
文章标签： spring 数据库 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_43975276/article/details/145016425
版权

配置

以下验证部分的配置：

技术栈版本
MySQL5.7.42
SpringBoot2.6.13

简述

下面说到的当前是指父方法是否有事务传递下来。

  • REQUIRED(默认)：当前存在事务则加入当前事务，不存在则创建一个事务。因为是共用事务，所以父方法catch子方法的异常还是会全部回滚。
  • SUPPORTS:当前存在事务则加入当前事务，不存在则以非事务方式运行。
  • MANDATORY：当前存在事务则加入当前事务，不存在则抛出异常。
  • REQUIRES_NEW：创建一个新事务，当前存在事务则挂起当前事务。
  • NOT_SUPPORTED：始终以非事务方法运行，当前存在事务则挂起当前事务。
  • NEVER：以非事务方法运行，当前存在事务则抛出异常。
  • NESTED：当前存在事务则创建子事务，父事务回滚会导致子事务回滚。而子事务回滚，如果父事务catch了异常则父事务不会回滚。当前不存在事务则创建新事务。

各种事务传播机制，指的是子事务使用该传播机制子方法和父方法的事务有什么关系。

后面的验证，如果没有特殊说明，默认父方法都正确处理子方法抛出的异常。事务是否回滚要结合数据库看，因为其中一个方法抛异常就会导致几个方法都回滚。

一、验证REQUIRED的事务传播机制

1.子事务回滚

	@Autowired
	private IMyAppUserService myAppUserService;
	@Override
	@Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
	public void testA() {
		try {
			MyAppUser myAppUser = new MyAppUser();
			myAppUser.setUserNo("A" + UUID.randomUUID());
			myAppUser.setNickName("A事务");
			this.save(myAppUser);
			myAppUserService.testB();
		} catch (Exception e) {
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			log.error("A事务回滚了");
		}
	}

	@Override
	@Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
	public void testB() {
		try {
			MyAppUser myAppUser = new MyAppUser();
			myAppUser.setUserNo("B" + UUID.randomUUID());
			myAppUser.setNickName("B事务");
			this.save(myAppUser);
			int a=10/0;
		} catch (Exception e) {
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			log.error("B事务回滚了");
		}
	}

结果：父事务回滚了，子事务也回滚了。符合共用一个事务的说法。

这里其实还涉及到一个知识点，网上找资料显示，这里会接着抛出异常，是因为子事务先回滚了，但父方法并不知道，于是继续执行，到后面要提交父事务的时候才发现子事务回滚了，父事务也就没法提交了，跟着回滚并抛出异常提醒。（这属于是子事务回滚带这父事务回滚）

在这里插入图片描述
在这里插入图片描述

2.父事务回滚

	@Autowired
	private IMyAppUserService myAppUserService;
	@Override
	@Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
	public void testA() {
		try {
			MyAppUser myAppUser = new MyAppUser();
			myAppUser.setUserNo("A" + UUID.randomUUID());
			myAppUser.setNickName("A事务");
			this.save(myAppUser);
			myAppUserService.testB();
			int a=10/0;
		} catch (Exception e) {
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			log.error("A事务回滚了");
		}
	}

	@Override
	@Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
	public void testB() {
		try {
			MyAppUser myAppUser = new MyAppUser();
			myAppUser.setUserNo("B" + UUID.randomUUID());
			myAppUser.setNickName("B事务");
			this.save(myAppUser);
		} catch (Exception e) {
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			log.error("B事务回滚了");
		}
	}

结果：父事务回滚了，子事务也回滚了，符合共用一个事务的说法。

在这里插入图片描述
在这里插入图片描述

结论：REQUIRED事务传播级别下，父子共用事务，随便一个回滚都会导致整个事务回滚。

二、验证REQUIRES_NEW的事务传播机制

1.子事务回滚

	@Autowired
	private IMyAppUserService myAppUserService;
	@Override
	@Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
	public void testA() {
		try {
			MyAppUser myAppUser = new MyAppUser();
			myAppUser.setUserNo("A" + UUID.randomUUID());
			myAppUser.setNickName("A事务");
			this.save(myAppUser);
			myAppUserService.testB();
		} catch (Exception e) {
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			log.error("A事务回滚了");
		}
	}

	@Override
	@Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRES_NEW)
	public void testB() {
		try {
			MyAppUser myAppUser = new MyAppUser();
			myAppUser.setUserNo("B" + UUID.randomUUID());
			myAppUser.setNickName("B事务");
			this.save(myAppUser);
			int a=10/0;
		} catch (Exception e) {
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			log.error("B事务回滚了");
		}
	}

结果：子事务回滚，父事务没有回滚。
在这里插入图片描述
在这里插入图片描述

2.父事务回滚

	@Autowired
	private IMyAppUserService myAppUserService;
	@Override
	@Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
	public void testA() {
		try {
			MyAppUser myAppUser = new MyAppUser();
			myAppUser.setUserNo("A" + UUID.randomUUID());
			myAppUser.setNickName("A事务");
			this.save(myAppUser);
			myAppUserService.testB();
			int a=10/0;
		} catch (Exception e) {
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			log.error("A事务回滚了");
		}
	}

	@Override
	@Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRES_NEW)
	public void testB() {
		try {
			MyAppUser myAppUser = new MyAppUser();
			myAppUser.setUserNo("B" + UUID.randomUUID());
			myAppUser.setNickName("B事务");
			this.save(myAppUser);
		} catch (Exception e) {
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			log.error("B事务回滚了");
		}
	}

结果：父事务回滚，子事务没有回滚。
在这里插入图片描述
在这里插入图片描述

结论：REQUIRES_NEW事务传播级别下，父事务和子事务是完全互相独立的事务，不会互相影响。

三、验证NESTED的事务传播机制

提前说明一点，如果子事务的异常往外抛，父方法没有正确处理，就相当于父方法也发生了异常，就会导致都回滚，这和事务传播机制没有关系。

1.子事务回滚

现在测试子事务回滚，但是子事务处理了自己的异常（或者父方法额外处理了），看看父事务会怎么样。

	@Autowired
	private IMyAppUserService myAppUserService;
	@Override
	@Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
	public void testA() {
		try {
			MyAppUser myAppUser = new MyAppUser();
			myAppUser.setUserNo("A" + UUID.randomUUID());
			myAppUser.setNickName("A事务");
			this.save(myAppUser);
			myAppUserService.testB();

		} catch (Exception e) {
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			log.error("A事务回滚了");
		}

	}

	@Override
	@Transactional(rollbackFor = Exception.class,propagation = Propagation.NESTED)
	public void testB() {
		try {
			MyAppUser myAppUser = new MyAppUser();
			myAppUser.setUserNo("B" + UUID.randomUUID());
			myAppUser.setNickName("B事务");
			this.save(myAppUser);
			int a=10/0;
		} catch (Exception e) {
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			log.error("B事务回滚了");
		}
	}

结果：结合日志和数据库，父事务的数据成功插入了。只有子事务回滚了，父事务不受影响。
在这里插入图片描述
在这里插入图片描述

2.父事务回滚

	@Autowired
	private IMyAppUserService myAppUserService;
	@Override
	@Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
	public void testA() {
		try {
			MyAppUser myAppUser = new MyAppUser();
			myAppUser.setUserNo("A" + UUID.randomUUID());
			myAppUser.setNickName("A事务");
			this.save(myAppUser);
			myAppUserService.testB();
			int a=10/0;
		} catch (Exception e) {
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			log.error("A事务回滚了");
		}

	}

	@Override
	@Transactional(rollbackFor = Exception.class,propagation = Propagation.NESTED)
	public void testB() {
		try {
			MyAppUser myAppUser = new MyAppUser();
			myAppUser.setUserNo("B" + UUID.randomUUID());
			myAppUser.setNickName("B事务");
			this.save(myAppUser);
		} catch (Exception e) {
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			log.error("B事务回滚了");
		}
	}

结果：子事务的数据也没有存下来，说明在回滚父事务时，会把子事务也一起回滚（虽然没有进入子方法的catch里面）。
在这里插入图片描述
在这里插入图片描述

3.子事务回滚，但父事务未正确处理子事务异常

这个其实很好理解，子方法的异常抛到父方法，父方法没有额外用一个try catch专门处理调用子方法的异常，自然就导致父方法也回滚。

	@Autowired
	private IMyAppUserService myAppUserService;
	@Override
	@Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
	public void testA() {
		try {
			MyAppUser myAppUser = new MyAppUser();
			myAppUser.setUserNo("A" + UUID.randomUUID());
			myAppUser.setNickName("A事务");
			this.save(myAppUser);
			myAppUserService.testB();
			int a=10/0;
		} catch (Exception e) {
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			log.error("A事务回滚了");
		}
	}

	@Override
	@Transactional(rollbackFor = Exception.class,propagation = Propagation.NESTED)
	public void testB() {
		try {
			MyAppUser myAppUser = new MyAppUser();
			myAppUser.setUserNo("B" + UUID.randomUUID());
			myAppUser.setNickName("B事务");
			this.save(myAppUser);
		} catch (Exception e) {
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			log.error("B事务回滚了");
			throw new RuntimeException("把异常抛出去");
		}
	}

结果：两个事务都回滚了。
在这里插入图片描述
在这里插入图片描述
结论：NESTED事务传播级别下，父事务和子事务存在影响关系，父事务回滚，子事务一定也回滚；子事务回滚，如果父事务正确处理子方法的异常，则父事务不会回滚。

总结论

  1. REQUIRED事务传播级别下，父子共用事务，随便一个回滚都会导致整个事务回滚。
  2. REQUIRES_NEW事务传播级别下，父事务和子事务是完全互相独立的事务，不会互相影响。
  3. NESTED事务传播级别下，父事务和子事务存在影响关系，父事务回滚，子事务一定也回滚；子事务回滚，如果父事务正确处理子方法的异常，则父事务不会回滚。

在某些场景下，如果子方法是用来处理一些不太重要的内容，希望这些子方法抛异常不会影响主流程，主流程回滚会回滚这些子方法，则可以考虑给这些子方法使用NESTED传播机制，例如日志打印。

Spring 事务 - 基本使用、传播机制、失效场景、嵌套事务多回滚解决
CYK_byte的博客
03-12 4910
带你一次学懂：编程式事务、声明式事务、事务的传播机制！
Spring 事务（3）—— Spring 事务传播行为详解
shangjg3的博客
06-29 1585
事务传播行为决定了在嵌套事务调用时，新事务如何与现有事务关联。例如，当一个带事务的方法调用另一个带事务的方法时，Spring 需要明确如何管理这些事务的边界。通过本文的介绍和示例代码，能够深入理解 Spring 事务传播行为的原理和使用方法，在实际开发中灵活运用，解决复杂业务场景下的事务管理问题。：无论当前是否存在事务，都会创建一个新事务，并挂起当前事务（如果存在）。如果没有事务，则抛出异常。：查询操作，不需要事务保证，但在事务中执行时需要参与事务。：以非事务方式执行，如果当前存在事务，则挂起该事务。
mysql事务详解
huangsky001的博客
02-04 703
以下的分析和总结都是针对InnoDb引擎. 事务的四大特性 这四个特性并不是平级的关系. 准确的说, 一致性是最基本的属性, 其他的属性都是为了保证一致性而存在的 Atomicity 原子性 原子性是指整个事务是一个整体，不可分割的最小工作单位。一个事务中的所有操作要么全部执行成功，要么全部都不执行。其中任何一条语句执行失败，都会导致事务回滚。 Consistency 一致性 指数据库的记录总是从一个一致性状态转变成另一个一致性状态。这里的一致性是语义上的一致性, 并不是语法上的一致性. 比如经典的银行
Spring事务默认传播行为PROPAGATION_REQUIRED：怎样做到异常被捕获处理后事务还会回滚
Linzhuank的博客
04-29 1433
Spring事务默认传播行为PROPAGATION_REQUIRED：怎样做到异常被捕获处理后事务还会回滚
关于抛异常后事务回滚的一点小事儿
ssH18868325485的博客
10-18 4640
关于抛异常后事务回滚的那些事儿 1.异常事务不回滚的情况，如果异常在当前方法上被try-catch，则事务不会回滚。(因为异常被处理了，等于没有异常。虽然这种代码肯定不会写) 2.如果异常在controller中try-catch,则会回滚(因为事务已经结束了，事务中确实发生了异常) 总结： 回滚不回滚，主要看事务是什么时候开启的，什么时候结束的。如上是在方法aaa()开启的事务，aaa()结束后事务也结束了。如果在aaa()中处理了异常，则表示一切正常，不会回滚。如果在事务结束后处理异常，则会回滚，因
@Transactional事务注解，以及在try-catch代码块中的回滚使用
qq_26112725的博客
06-06 2949
同一个类中，一个没有事务的方法A，去调用另一个有事务的方法B时，因为是直接调用，而不是调用的代理类，所以事务不起用的。自动回滚：动回滚只需要在对应的方法下添加@Transactional注解，1.用在类上，那么对该类下所有public方法都有效。2.也可写在某个方法上（只能是public方法）不需要对方法内容进行try-catch。手动回滚：如果在方法中有使用。的出常，事务才会回滚。
事务
kk屯学的博客
12-04 372
/** * 事务传播 - Propagation * REQUIRED: 使用当前的事务，如果当前没有事务，则自己新建一个事务，子方法是必须运行在一个事务中的； * 如果当前存在事务，则加入这个事务，成为一个整体。 * 举例：领导没饭吃，我有钱，我会自己买了自己吃；领导有的吃，会分给你一起吃。 * SUPP...
Spring事务传播行为详解
刘树之的博客
08-17 700
前言 Spring在TransactionDefinition接口中规定了7种类型的事务传播行为。事务传播行为是Spring框架独有的事务增强(通知)特性，是Spring为我们提供的强大的工具箱，使用事务传播行可以为我们的开发工作提供许多便利。但是人们对他的误解也颇多，你一定也听过“service方法事务最好不要嵌套”的传言。要想正确的使用工具首先需要了解工具。本文对七种事务传播行为做详细介绍，内容主要代码示例的方式呈现。 基础概念 1.什么是事务传播行为？ 事务传播行为用来描述由某一个事务传播行为修饰的方
深入解析 Spring 事务机制
MarkusZhang的博客
02-06 1133
在数据库和软件开发领域，事务是一组相关的操作，被视为不可分割的执行单位。事务具有四个关键数据，简称ACID原子性（Atomicity）：事务是原子的，它要么全部执行成功，要么完全不执行。如果事务的任何部分失败，整个事务将回滚到初始状态，不会留下部分完成的结果。一致性（Consistency）：事务在执行前后，数据库的状态应保持一致。这意味着事务的执行不会破坏数据库的完整性约束，如唯一性约束、外键约束等。隔离性（Isolation）：多个事务并发执行时，每个事务都应该被隔离，以防止彼此之间的干扰。
spring 的嵌套事务
chenxing3355的博客
06-29 438
关于spring的嵌套事务，网上说是利用jdbc的安全点实行的，并且 1，父事务回滚，子事务会回滚 2，子事务回滚，不会影响父事务 但我实际试验时却发现不管是由子事务还是父事务抛出异常，父子事务都会进行回滚 解答 首先第一点， spring的嵌套事务，是利用jdbc的安全点，这说法...
子事务和父事务mysql_MySQL事务和事务隔离级别
weixin_34049581的博客
02-03 1251
1、概述事务就是对数据库数据进行更改(包括insert、update、delete等)操作的一个执行单元，通常有一条或多条更改语句组成。在同一个事务中的更改操作要么同时成功，要么同时失败。事务具有4个属性：原子性、一致性、隔离性、持久性。即 ACID 特性。原子性(atomicity)：同一个事务中的更改操作要么同时成功，要么同时失败。一致性(consistency)：事务必须是使数据库从一个一致...
spring事务的传播机,嵌套事务详解,事务失效的场景
weixin_38860401的博客
03-12 2199
spring事务控制
Spring事务管理解析
qq_46631261的博客
08-21 394
事务，事务传播机制，声明式事务，xml/注解实现事务，jdbc
Spring中父子事务回滚情况
最新发布
qq_46130027的博客
02-25 315
父事务回滚：父事务的回滚会导致所有子事务回滚，除非子事务使用 REQUIRES_NEW 传播行为。子事务回滚：子事务的回滚会影响父事务的回滚，具体影响取决于传播行为（如 REQUIRES_NEW 会忽略父事务的回滚）
内层事务方法try catch了，当内部抛出异常回滚，会触发外部事务回滚
胖墩的IT博客
07-06 3887
场景：接口A的方法A1，接口B的方法B1，都添加了事务的注解，接口A的方法A1先修改数据库，之后再调用接口B的方法B1，其中调用方法B1有try catch捕获异常，但是不往外抛异常，那此时如果方法B1有一场了，那会触发方法A中修改数据的操作吗？答案是会触发，当前此前提的基础是用的是 @Transactional 注解，并且采用的是默认的事务 1、例子 (1)例子的单元测试 @SpringBootTest @RunWith(SpringJUnit4ClassRunner.class) public c.
Spring学习day04
weixin_44969679的博客
09-26 219
1、事务 如果在一个功能单元【方法】执行过程中保持原子性，涉及到对数据库的多次操作，而且，我们希望这个功能单元可以看做一个最小执 行单位，里面涉及到对数据库的多次操作要么同时成功，要么同时失败！ 1）编程式事务 //1.获取Connection对象 Connection conn = JDBCUtils.getConnection(); try { //2.开启事务：取消...
Spring 控制事务回滚（setRollbackOnly）
inpiwbs的博客
02-10 3441
setRollbackOnly只是作为一个标记在方法结束后才会真正的去做回滚,而不是立马做回滚此时如果executeMtrlExport方法发生异常，日志的插入也会被回滚可以设置插入日志的方法的事务传播特性为 REQUIRES_NEW。
使用Spring管理，在try-catch后不会滚解决
疯子的博客
10-20 2486
默认spring事务只在发生未被捕获的 runtimeexcetpion时才回滚。spring aop  异常捕获原理：被拦截的方法需显式抛出异常，并不能经任何处理，这样aop代理才能捕获到方法的异常，才能进行回滚，默认情况下aop只捕获runtimeexception的异常，但可以通过配置来捕获特定的异常并回滚，换句话说在service的方法中不使用try catch 或者在catch中最后加上
Spring事务传播
01-10
### Spring 框架中的事务传播机制 #### 解释 Spring框架中的事务传播行为定义了当一个事务方法被另一个事务方法调用时的行为方式。这种特性允许开发人员灵活控制不同业务逻辑间的事务边界，确保数据一致性和完整性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值