【源码】Spring事务之传播特性的详解

已于 2024-06-17 16:57:32 修改
阅读量1k 收藏 19
点赞数 25
文章标签： Spring源码 SpringBoot源码 Spring事务源码 Transaction源码 事务传播特性 事务传播特性原理 Propagation
于 2024-06-17 16:52:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JingAi_jia917/article/details/139744368
版权

Spring事务系列

1、【源码】SpringBoot事务注册原理

2、【源码】Spring Data JPA原理解析之事务注册原理

3、【源码】Spring Data JPA原理解析之事务执行原理

4、【源码】SpringBoot编程式事务使用及执行原理

5、【源码】Spring事务之传播特性的详解

6、【源码】Spring事务之事务失效及原理

前言

《Spring事务系列》的前面4篇博文从源码的角度分析了Spring事务的注册以及执行原理，本篇分享一下事务的传播特性。

事务传播特性

Spring事务包含七种的传播特性，在Propagation枚举类中，分别如下：

1）REQUIRE：如果当前没有事务，则新创建一个事务；如果上下文存在事务，则加入到这个事务中。默认值；

2）SUPPORTS：如果当前上下文存在事务，则加入这个事务；如果上下文不存在事务，则使用无事务的方式执行。即：如果上下文有事务，则加入这个事务；否则直接执行，不会新创建事务；

3）MANDATORY：如果当前上下文存在事务，则加入这个事务；如果上下文不存在事务，则报错；

4）REQUIRES_NEW：每次都新创建一个事务。如果当前上下文有事务，则挂起上下文的事务，重新创建一个事务；如果当前上下文没有事务，新创建一个事务；

如：ServiceA.method()调用ServiceB.method()，在ServiceB.method()使用REQUIRES_NEW传播特性。如果ServiceB.method()提交后，ServiceA.method()报错，则ServiceB.method()不会回滚，ServiceA.method()会回滚；如果ServiceB.method()报错，则ServiceA.method()可以通过捕获异常，选择回滚或提交。

5）NOT_SUPPORTED：不支持事务执行。如果当前上下文存在事务，则挂起上下文事务；

如：ServiceA.method()调用ServiceB.method()，在ServiceB.method()使用NOT_SUPPORTED传播特性，则ServiceB.method()的执行不在事务范围内。如果ServiceB.method()报错，则ServiceA.method()可以通过捕获异常，选择回滚或提交。

6）NEVER：无事务执行。如果当前上下文存在事务，则抛异常；

如：ServiceA.method()调用ServiceB.method()，在ServiceB.method()使用NEVER传播特性，则ServiceB.method()的整条调用链中都不能创建事务，否则会报错。

7）NESTED：嵌套事务。如果上下文存在事务，则在嵌套的事务中执行；如果上下文没有事务，则新创建一个事务；

如：ServiceA.method()调用ServiceB.method()，在ServiceB.method()使用NESTED传播特性。如果ServiceB.method()报错，则只回滚ServiceB.method()中的信息，对ServiceA.method()没有影响。通过savepoint实现。

源码解析

事务的传播特性可以通过@Transactional注解的propagation属性进行设置，对于Propagation枚举类中每一种传播特性，在TransactionDefinition中都对应一个属性值。

3.1 Propagation

Propagation的源码如下：

public enum Propagation {
	
	// 需要事务。如果当前没有事务，则新创建一个事务；如果上下文存在事务，则加入到这个事务中。默认值；
	REQUIRED(TransactionDefinition.PROPAGATION_REQUIRED),

	// 如果当前上下文存在事务，则加入这个事务；如果上下文不存在事务，则使用无事务的方式执行。即：如果上下文有事务，则加入这个事务；否则直接执行，不会新创建事务；
	SUPPORTS(TransactionDefinition.PROPAGATION_SUPPORTS),

	// 如果当前上下文存在事务，则加入这个事务；如果上下文不存在事务，则报错；
	MANDATORY(TransactionDefinition.PROPAGATION_MANDATORY),

	// 每次都新创建一个事务。如果当前上下文有事务，则挂起上下文的事务，重新创建一个事务；如果当前上下文没有事务，新创建一个事务；
	REQUIRES_NEW(TransactionDefinition.PROPAGATION_REQUIRES_NEW),
	
	// 不支持事务执行。如果当前上下文存在事务，则挂起上下文事务；
	NOT_SUPPORTED(TransactionDefinition.PROPAGATION_NOT_SUPPORTED),

	// 无事务执行。如果当前上下文存在事务，则抛异常；
	NEVER(TransactionDefinition.PROPAGATION_NEVER),

	// 嵌套事务。如果上下文存在事务，则在嵌套的事务中执行；如果上下文没有事务，则新创建一个事务；
	NESTED(TransactionDefinition.PROPAGATION_NESTED);


	private final int value;


	Propagation(int value) {
		this.value = value;
	}

	public int value() {
		return this.value;
	}

}

3.2 传播特性判断

Spring事务中的传播特性在AbstractPlatformTransactionManager类中进行判断，详见

【源码】Spring Data JPA原理解析之事务执行原理-CSDN博客

传播特性判断的核心代码如下：

public abstract class AbstractPlatformTransactionManager implements PlatformTransactionManager, Serializable {

	@Override
	public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException {
		// 抽象方法。如JpaTransactionManager.doGetTransaction()，创建一个JpaTransactionObject对象，开启一个新的Connection
		Object transaction = doGetTransaction();

		boolean debugEnabled = logger.isDebugEnabled();

		if (definition == null) {
			definition = new DefaultTransactionDefinition();
		}
		// 如果事务存在，则检测传播行为并返回
		if (isExistingTransaction(transaction)) {
			// 找到现有事务->检查传播行为以了解行为方式
			return handleExistingTransaction(definition, transaction, debugEnabled);
		}

		// 检查事务属性中的超时属性，默认为-1
		if (definition.getTimeout() < TransactionDefinition.TIMEOUT_DEFAULT) {
			throw new InvalidTimeoutException("Invalid transaction timeout", definition.getTimeout());
		}

		// 如果事务的传播特性为PROPAGATION_MANDATORY，则抛异常
		if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
			throw new IllegalTransactionStateException(
					"No existing transaction found for transaction marked with propagation 'mandatory'");
		}
		// 如果事务的传播特性为PROPAGATION_REQUIRED、PROPAGATION_REQUIRES_NEW、PROPAGATION_NESTED，
		// 此时没有事务，所以需要创建新的事务
		else if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||
				definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||
				definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
			// 挂起事务，此处返回的suspendedResources为null
			SuspendedResourcesHolder suspendedResources = suspend(null);
			if (debugEnabled) {
				logger.debug("Creating new transaction with name [" + definition.getName() + "]: " + definition);
			}
			try {
				// 初始getTransactionSynchronization()为0，需要激活事务同步
				// SYNCHRONIZATION_NEVER为2，表示不激活事务同步
				boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
				// 创建一个DefaultTransactionStatus对象，传入刚创建的transaction对象，新开启一个连接
				DefaultTransactionStatus status = newTransactionStatus(
						definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
				// 开始事务
				doBegin(transaction, definition);
				// 准备同步，将事务相关信息保存到本地线程变量
				prepareSynchronization(status, definition);
				return status;
			}
			catch (RuntimeException | Error ex) {
				resume(null, suspendedResources);
				throw ex;
			}
		}
		else {
			// 传播特性为PROPAGATION_SUPPORTS、PROPAGATION_NOT_SUPPORTED、PROPAGATION_NEVER，此时没有事务，则不开启事务执行
			if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT && logger.isWarnEnabled()) {
				logger.warn("Custom isolation level specified but no actual transaction initiated; " +
						"isolation level will effectively be ignored: " + definition);
			}
			boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
			// 创建一个DefaultTransactionStatus对象，此处的transaction为null
			return prepareTransactionStatus(definition, null, true, newSynchronization, debugEnabled, null);
		}
	}

	private TransactionStatus handleExistingTransaction(
			TransactionDefinition definition, Object transaction, boolean debugEnabled)
			throws TransactionException {

		// 如果事务的传播特性为PROPAGATION_NEVER，因为上下文存在事务，则抛异常
		if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NEVER) {
			throw new IllegalTransactionStateException(
					"Existing transaction found for transaction marked with propagation 'never'");
		}
		// 如果事务的传播特性为PROPAGATION_NOT_SUPPORTED，因为上下文存在事务，则挂起事务
		if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NOT_SUPPORTED) {
			if (debugEnabled) {
				logger.debug("Suspending current transaction");
			}
			Object suspendedResources = suspend(transaction);
			boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
			// 创建一个DefaultTransactionStatus对象，此处的transaction为null
			return prepareTransactionStatus(
					definition, null, false, newSynchronization, debugEnabled, suspendedResources);
		}
		// 如果事务的传播特性为PROPAGATION_REQUIRES_NEW，因为上下文存在事务，则挂起事务，新创建一个事务
		if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW) {
			if (debugEnabled) {
				logger.debug("Suspending current transaction, creating new transaction with name [" +
						definition.getName() + "]");
			}
			SuspendedResourcesHolder suspendedResources = suspend(transaction);
			try {
				boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
				// 创建一个DefaultTransactionStatus对象，此处的transaction为新创建的事务
				DefaultTransactionStatus status = newTransactionStatus(
						definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
				// 开启事务
				doBegin(transaction, definition);
				prepareSynchronization(status, definition);
				return status;
			}
			catch (RuntimeException | Error beginEx) {
				resumeAfterBeginException(transaction, suspendedResources, beginEx);
				throw beginEx;
			}
		}
		// 如果事务的传播特性为PROPAGATION_NESTED，因为上下文存在事务，则使用嵌套事务
		if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
			if (!isNestedTransactionAllowed()) {
				throw new NestedTransactionNotSupportedException(
						"Transaction manager does not allow nested transactions by default - " +
						"specify 'nestedTransactionAllowed' property with value 'true'");
			}
			if (debugEnabled) {
				logger.debug("Creating nested transaction with name [" + definition.getName() + "]");
			}
			// 如果支持savepoint保存点，则创建保存点
			if (useSavepointForNestedTransaction()) {
				DefaultTransactionStatus status =
						prepareTransactionStatus(definition, transaction, false, false, debugEnabled, null);
				status.createAndHoldSavepoint();
				return status;
			}
			else { // 否则的话，创建新的事务
				boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
				DefaultTransactionStatus status = newTransactionStatus(
						definition, transaction, true, newSynchronization, debugEnabled, null);
				doBegin(transaction, definition);
				prepareSynchronization(status, definition);
				return status;
			}
		}

		if (debugEnabled) {
			logger.debug("Participating in existing transaction");
		}
		// 判断是否需要验证现有的事务
		if (isValidateExistingTransaction()) {
			// 隔离级别判断
			if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {
				Integer currentIsolationLevel = TransactionSynchronizationManager.getCurrentTransactionIsolationLevel();
				if (currentIsolationLevel == null || currentIsolationLevel != definition.getIsolationLevel()) {
					Constants isoConstants = DefaultTransactionDefinition.constants;
					throw new IllegalTransactionStateException("Participating transaction with definition [" +
							definition + "] specifies isolation level which is incompatible with existing transaction: " +
							(currentIsolationLevel != null ?
									isoConstants.toCode(currentIsolationLevel, DefaultTransactionDefinition.PREFIX_ISOLATION) :
									"(unknown)"));
				}
			}
			if (!definition.isReadOnly()) {
				if (TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {
					throw new IllegalTransactionStateException("Participating transaction with definition [" +
							definition + "] is not marked as read-only but existing transaction is");
				}
			}
		}
		boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
		// 继续执行事务
		return prepareTransactionStatus(definition, transaction, false, newSynchronization, debugEnabled, null);
	}

}

事务的传播特性判断在AbstractPlatformTransactionManager的getTransaction()和handleExistingTransaction()方法。

3.2.1 getTransaction()

getTransaction()方法主要执行如下：

1）执行抽象方法doGetTransaction()，获取一个事务对象。如如JpaTransactionManager.doGetTransaction()，创建一个JpaTransactionObject对象，开启一个新的Connection；

2）判断上下文是否存在事务，如果有，则执行handleExistingTransaction()方法；

3）如果没有事务，执行如下：

3.1）如果事务的传播特性为PROPAGATION_MANDATORY，则抛异常；

3.2）如果事务的传播特性为PROPAGATION_REQUIRED或PROPAGATION_REQUIRES_NEW或PROPAGATION_NESTED，此时没有事务，所以需要创建新的事务；

3.3）否则，传播特性为PROPAGATION_SUPPORTS或PROPAGATION_NOT_SUPPORTED或PROPAGATION_NEVER，此时没有事务，则不开启事务，继续执行；

3.2.2 handleExistingTransaction()

handleExistingTransaction()执行时，说明当前上下文存在事务，方法主要执行如下：

1）如果事务的传播特性为PROPAGATION_NEVER，因为上下文存在事务，则抛异常；

2）如果事务的传播特性为PROPAGATION_NOT_SUPPORTED，因为上下文存在事务，则挂起事务，继续执行；

3）如果事务的传播特性为PROPAGATION_REQUIRES_NEW，因为上下文存在事务，则挂起事务，新创建一个事务；

4）如果事务的传播特性为PROPAGATION_NESTED，因为上下文存在事务，则使用嵌套事务；

4.1）如果支持savepoint保存点，则创建保存点。如果保存点中的报异常，则只回滚保存点的事务；

4.2）如果不支持savepoint，则创建新事务；

小结

在实际的项目中，需要根据实际的业务需要，设置合理的传播特性，使用不当，不仅会导致事务失效，还可能导致数据不一致问题。

以上为本篇分享的全部内容，关于本篇内容你有什么自己的想法或独到见解，欢迎在评论区一起交流探讨下吧。

Spring事务传播特性解析
11-05
通过代码解析spring传播特性，包括 1、Propagation.REQUIRED 方法被调用时自动开启事务，在事务范围内使用则使用同一个事务，否则开启新事务。 2、Propagation.REQUIRES_NEW 无论何时自身都会开启事务 3、Propagation.SUPPORTS 自身不会开启事务，在事务范围内则使用相同事务，否则不使用事务 4、Propagation.NOT_SUPPORTED 自身不会开启事务，在事务范围内使用挂起事务，运行完毕恢复事务 5、Propagation.MANDATORY 自身不开启事务，必须在事务环境使用否则报错 6、Propagation.NEVER 自身不会开启事务，在事务范围使用抛出异常 7、Propagation.NESTED 如果一个活动的事务存在，则运行在一个嵌套的事务中. 如果没有活动事务, 则按TransactionDefinition.PROPAGATION_REQUIRED 属性执行。需要JDBC3.0以上支持。
Spring5源码之Spring七种传播特性的详解
m0_65403567的博客
12-16 710
七种事务传播特性： 本篇文章主要讲解Spring事务的传播属性，先看一下下表： 传播特性名称 PROPAGATION_REQUIRED 如果当前没有事物，则新建一个事物；如果已经存在一个事物，则加入到这个事物中 PROPAGATION_SUPPORTS 支持使用当前事务，如果当前事务不存在，则不使用事务。** 解释：** 如果ServiceA.method开了事务，那么ServiceB就将自己加入ServiceA中来运行，如果ServiceA.method没有开事务，那么Se
Spring事务的传播特性
红豆和绿豆的博客
11-07 428
https://blog.csdn.net/lovesomnus/article/details/69942697 传播行为    描述 PROPAGATION_REQUIRED    如果没有，就开启一个事务；如果有，就加入当前事务（方法B看到自己已经运行在 方法A的事务内部，就不再起新的事务，直接加入方法A） RROPAGATION_REQUIRES_NEW    如果没有，就开启一个事务；...
Spring 事务和事务传播机制（详解）
最新发布
2401_83177222的博客
02-26 1337
Spring 事务传播机制定义了多个包含了事务的⽅法，相互调⽤时，事务是如何在这些⽅法间进⾏传递的Spring中使用事务,有两种方式:编程式事务(手动操作)和声明式事务.其中声明式事务使用较多,在方法上添加就可以实现了通过）设置事务的隔离级别.Spring 中的事务隔离级别有 5种通过设置事务的传播机制, Spring 中的事务传播级别有7种,重点关注REQUIRED(默认值)和。
Spring的事务传播特性
qq_37933128的博客
10-05 2298
事务属性的种类：传播行为、隔离级别、只读和事务超时。事务传播行为就是多个事务方法相互调用时，事务如何在这些方法间传播。
spring事务的传播特性
zqj1172102457的博客
07-27 2937
什么是事务的传播特性? A,B两个方法都有事务，在A方法中去调用B方法，此时事务方法应该如何进行处理。 比如 A方法里面调用B方法。 情况一：A方法出现异常，A方法需要回滚，那么B方法需不需要回滚呢？ 情况二：B方法出现异常，B方法需要回滚，那么A方法需不需要回滚呢？ spring总共给出了7种事务隔离级别: 1、PROPAGATION_REQUIRED:默认事务类型，如果没有，就新建一个事务;如果有，就加入当前事务。适合绝大多数情况。 解释：方法A中调用方法B，B方法的事务传播设置为PROPAGATION
Spring事务底层源码解析(一)
qq_40228720的博客
10-21 1243
我们在看了jdbc 代码以后可以清楚的知道，事务就是由connection 对象控制的，所以 connection 对象是和事务是绑定的，然后用户请求过来时又需要数据库连接来执行sql 语句， 所以用户请求线程又是跟connection 是绑定的。再看下核心的advice，生成后的代理对象，在调用方法的时候最终会先执行到TransactionInterceptor的invoke方法，然后再invokeWithinTransaction方法里面完成了事务的开启，原始方法的调用，事物的提交和回滚等。
8个示例详解 Spring 事务传播机制(附测试源码)
qq_64513388的博客
01-18 547
什么是事务传播机制 事务的传播机制，顾名思义就是多个事务方法之间调用，事务如何在这些方法之间传播。 举个例子，方法 A 是一个事务的方法，方法 A 执行的时候调用了方法 B,此时方法 B 有无事务以及是否需要事务都会对方法 A 和方法 B 产生不同的影响，而这个影响是由两个方法的事务传播机制决定的。 传播属性 Propagation 枚举 Spring 对事务的传播机制在Propagation枚举中定义了7个分类： REQUIRED 默认 SUPPORTS 支持 MANDATORY 强制 ..
Spring源码（八）：Spring事务详解
JustPlayCode的博客
06-21 1064
如果多个DML语句是同一个连接对象操作的，他们的算作同一个事务，前提是关闭自动提交 Spring事务切面 事务切面开启注解@EnableTransactionManagement，由注解上的@Import(TransactionManagementConfigurationSelector.class)来到selectImports方法。PROXY代表JDK事务，引入了AutoProxyRegistrar和ProxyTransactionManagementConfiguration。 AutoProxy
Spring事务管理案例详解及源码解析
资源摘要信息:"spring事务案例分析.zip" 在深入分析这份标题为"spring事务案例分析.zip"的压缩包内容之前，我们首先要了解Spring框架中的事务管理机制。Spring的事务管理提供了一种编程和声明式事务管理的简单方式...
【Spring学习34】Spring事务(4)：事务属性之7种传播行为
热门推荐
程序老兵的博客
04-20 1万+
事务传播行为什么叫事务传播行为？听起来挺高端的，其实很简单。 即然是传播，那么至少有两个东西，才可以发生传播。单体不存在传播这个行为。事务传播行为（propagation behavior）指的就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行。 例如：methodA事务方法调用methodB事务方法时，methodB是继续在调用者methodA的事务中运行呢，还是为自己开启一个
spring事物传播属性
weixin_34242509的博客
08-02 152
PROPAGATION_REQUIRED Support a current transaction; create a new one if none exists. 支持一个当前事务;如果不存在，创建一个新的。 This is typically the default setting of a transaction definition,and typically defin...
spring事务传播特性
weixin_40413961的博客
02-25 835
spring事务传播特性 什么是事物呢？ 事务是一系列的动作（逻辑update，insert，delte…），它们综合在一起才是一个完整的工作单元，这些动作必须全部完成，如果有一个失败的话，那么事务就会回滚到最开始的状态，可以想一下0和1 ，你把0变成1的过程就比作事务，这个过程中如果遇到问题就会失败就会变为原有状态0,而不会出现0.5等值，如果成功就是1，我们不难发现这个事务需要正确的执行有几...
事物的传播行为
weixin_41202749的博客
09-07 305
1.在外围方法未开启事务的情况下Propagation.REQUIRED修饰的内部方法会新开启自己的事务，且开启的事务相互独立，互不干扰。 2.在外围方法开启事务的情况下Propagation.REQUIRED修饰的内部方法会加入到外围方法的事务中，所有Propagation.REQUIRED修饰的内部方法和外围方法均属于同一事务，只要一个方法回滚，整个事务均回滚.抛出异常或者异常捕获到都回滚 3.在外围方法未开启事务的情况下Propagation.REQUIRES_NEW修饰的内部方法会新开启自己的事务，
SPRING的事务传播特性
renxingzhadan的专栏
06-17 106
事务属性的种类：传播行为、隔离级别、只读和事务超时 a)传播行为定义了被调用方法的事务边界。 传播行为 意义 PROPERGATION_MANDATORY 表示方法必须运行在一个事务中，如果当前事务不存在，就抛出异常 PROPAGATION_NESTED 表示如果当前事务存在，则方法应该运行在一个嵌套事务中。否则，它看起来和PROPAGATION_REQUIRED...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值