Spring5 源码阅读笔记（4.1.1.2）handleExistingTransaction(definition, transaction, debugEnabled) 处理存在的事务

最新推荐文章于 2023-04-21 17:36:19 发布

君莫笑(๑˙ー˙๑)

最新推荐文章于 2023-04-21 17:36:19 发布

阅读量445

点赞数 1

分类专栏： # Transaction

本文链接：https://blog.csdn.net/weixin_44367006/article/details/104680433

版权

Transaction 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

每当进入事务切面，Spring 在创建事务的时候都会先新建一个事务对象 DataSourceTransactionObject，见 Spring5 源码阅读笔记（4.1.1.1）doGetTransaction() 拿事务对象。这个事务对象里面有一个 ConnectionHolder，并且这个连接不是新的，newTransaction 为 false。当然，这是默认值，ConnectionHolder 也可能为空。

然后会判断是否已经存在事务，也就是当前事务是一个内层事务。
判断的条件是，前面说的 ConnectionHolder 不为空，且为活跃状态。

@Override
protected boolean isExistingTransaction(Object transaction) {
	DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
	return (txObject.hasConnectionHolder() && txObject.getConnectionHolder().isTransactionActive());
}

如果为 true，就会执行本小节的代码。

重点
如果传播方式是 ROPAGATION_REQUIRES_NEW：

挂起。设置本 DataSourceTransactionObject 的 ConnectionHolder 为空（不用外层事务的连接），解除当前线程与<数据源,连接>的绑定。
设置状态，是新连接，newTransaction 设置为 true
获取新连接，关闭自动提交，绑定线程与数据源连接的关系（doBegin）

如果传播方式是 PROPAGATION_NESTED：

还是用外层事务的连接，newTransaction 设置为 false（本来也是 false）
创建回滚点（嵌套事务相当于外层事务的一个回滚点）

如果传播方式是默认的，PROPAGATION_REQUIRED：

还是用外层事务的连接，newTransaction 设置为 false（本来也是 false）

注意：传播方式，是进入切面的按顺序传播，由外到内，在同一层由代码顺序排序。也就是说事务切面在源码中的传播是一条链，是不区别内外层的。前面的总结，从结果上来看来也不算错，但是从源码来说不算准确。

在这里插入图片描述

跟源码
类 AbstractPlatformTransactionManager

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

	//不允许有事务，直接异常
	if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NEVER) {
		throw new IllegalTransactionStateException(
				"Existing transaction found for transaction marked with propagation 'never'");
	}

	//以非事务方式执行操作，如果当前存在事务，就把当前事务挂起
	if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NOT_SUPPORTED) {
		if (debugEnabled) {
			logger.debug("Suspending current transaction");
		}
		//挂起当前事务
		Object suspendedResources = suspend(transaction);
		boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
		//修改事务状态信息，把事务的一些信息存储到当前线程中，ThreadLocal中
		return prepareTransactionStatus(
				definition, null, false, newSynchronization, debugEnabled, suspendedResources);
	}

	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 status = newTransactionStatus(
					definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
			//见4.1.3 获取新连接，关闭自动提交，绑定数据源和连接的关系
			doBegin(transaction, definition);
			prepareSynchronization(status, definition);
			return status;
		}
		catch (RuntimeException | Error beginEx) {
			resumeAfterBeginException(transaction, suspendedResources, beginEx);
			throw beginEx;
		}
	}

	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() + "]");
		}
		//默认是可以嵌套事务的
		if (useSavepointForNestedTransaction()) {
			// Create savepoint within existing Spring-managed transaction,
			// through the SavepointManager API implemented by TransactionStatus.
			// Usually uses JDBC 3.0 savepoints. Never activates Spring synchronization.
			DefaultTransactionStatus status =
					prepareTransactionStatus(definition, transaction, false, false, debugEnabled, null);
			//创建回滚点
			status.createAndHoldSavepoint();
			return status;
		}
		else {
			// Nested transaction through nested begin and commit/rollback calls.
			// Usually only for JTA: Spring synchronization might get activated here
			// in case of a pre-existing JTA transaction.
			boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
			DefaultTransactionStatus status = newTransactionStatus(
					definition, transaction, true, newSynchronization, debugEnabled, null);
			doBegin(transaction, definition);
			prepareSynchronization(status, definition);
			return status;
		}
	}

	// Assumably PROPAGATION_SUPPORTS or PROPAGATION_REQUIRED.
	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);
	//默认传播属性,还是用旧连接，true变false
	return prepareTransactionStatus(definition, transaction, false, newSynchronization, debugEnabled, null);
}

跟 suspend：

@Nullable
protected final SuspendedResourcesHolder suspend(@Nullable Object transaction) throws TransactionException {
	if (TransactionSynchronizationManager.isSynchronizationActive()) {
		List<TransactionSynchronization> suspendedSynchronizations = doSuspendSynchronization();
		try {
			Object suspendedResources = null;
			//如果外层事务存在
			if (transaction != null) {
				//把connectionHolder设置为空，拿到挂起的连接
				suspendedResources = doSuspend(transaction);
			}

			//做数据还原操作
			String name = TransactionSynchronizationManager.getCurrentTransactionName();
			TransactionSynchronizationManager.setCurrentTransactionName(null);
			boolean readOnly = TransactionSynchronizationManager.isCurrentTransactionReadOnly();
			TransactionSynchronizationManager.setCurrentTransactionReadOnly(false);
			Integer isolationLevel = TransactionSynchronizationManager.getCurrentTransactionIsolationLevel();
			TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(null);
			boolean wasActive = TransactionSynchronizationManager.isActualTransactionActive();
			TransactionSynchronizationManager.setActualTransactionActive(false);
						//封装了挂起的连接
			return new SuspendedResourcesHolder(
					suspendedResources, suspendedSynchronizations, name, readOnly, isolationLevel, wasActive);
		}
		catch (RuntimeException | Error ex) {
			// doSuspend failed - original transaction is still active...
			doResumeSynchronization(suspendedSynchronizations);
			throw ex;
		}
	}
	else if (transaction != null) {
		// Transaction active but no synchronization active.
		Object suspendedResources = doSuspend(transaction);
		return new SuspendedResourcesHolder(suspendedResources);
	}
	else {
		// Neither transaction nor synchronization active.
		return null;
	}
}

跟 doSuspend：
类 DataSourceTransactionManager

@Override
protected Object doSuspend(Object transaction) {
	DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
	//事务对象和连接是挂钩的，如果连接对象设置为空，说明不用上一个事务了
	txObject.setConnectionHolder(null);
	//解除绑定关系，返回的是挂起的连接
	return TransactionSynchronizationManager.unbindResource(obtainDataSource());
}

跟 unbindResource：
类 TransactionSynchronizationManager

public static Object unbindResource(Object key) throws IllegalStateException {
	Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);
	Object value = doUnbindResource(actualKey);
	if (value == null) {
		throw new IllegalStateException(
				"No value for key [" + actualKey + "] bound to thread [" + Thread.currentThread().getName() + "]");
	}
	//返回的是挂起的连接
	return value;
}

跟 doUnbindResource：

@Nullable
private static Object doUnbindResource(Object actualKey) {
		//<数据源,连接>
	Map<Object, Object> map = resources.get();
	if (map == null) {
		return null;
	}
	Object value = map.remove(actualKey);
	// Remove entire ThreadLocal if empty...
	if (map.isEmpty()) {
		resources.remove();
	}
	// Transparently suppress a ResourceHolder that was marked as void...
	if (value instanceof ResourceHolder && ((ResourceHolder) value).isVoid()) {
		value = null;
	}
	if (value != null && logger.isTraceEnabled()) {
		logger.trace("Removed value [" + value + "] for key [" + actualKey + "] from thread [" +
				Thread.currentThread().getName() + "]");
	}
	//返回的是挂起的连接
	return value;
}