（十二）Spring事务处理 - 事务处理的实现

在Spring的事务处理中，通用的事务处理流程框架是由抽象事务管理器AbstractPlatformTransactionManager来提供，而具体的底层事务处理实现，由PlatformTransactionManager的具体实现类来实现，如 DataSourceTransactionManager 、JtaTransactionManager和 HibernateTransactionManager等。

一、抽象事务管理器AbstractPlatformTransactionManager获取事务

抽象事务管理器AbstractPlatformTransactionManager提供了创建事务的模板，这个模板会被具体的事务处理器所使用，抽象事务管理器根据事务属性配置和当前线程绑定信息对事务是否需要创建以及如何创建进行一些通用的处理，然后把事务创建的底层细节交给具体的事务处理器实现。抽象事务管理器创建事务的模板方法如下：

public final TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException {
		//doGetTransaction()方法是抽象方法，具体的实现由具体的事务处理器提供
		Object transaction = doGetTransaction();
		boolean debugEnabled = logger.isDebugEnabled();
		//如果没有配置事务属性，则使用默认的事务属性
		if (definition == null) {
			definition = new DefaultTransactionDefinition();
		}
		//检查当前线程是否存在事务
		if (isExistingTransaction(transaction)) {
			//处理已存在的事务
			return handleExistingTransaction(definition, transaction, debugEnabled);
		}
		//检查事务属性中timeout超时属性设置是否合理
		if (definition.getTimeout() < TransactionDefinition.TIMEOUT_DEFAULT) {
			throw new InvalidTimeoutException("Invalid transaction timeout", definition.getTimeout());
		}
		//对事务属性中配置的事务传播特性处理
		//如果事务传播特性配置的是mandatory，当前没有事务存在，抛出异常
		if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
			throw new IllegalTransactionStateException(
					"No existing transaction found for transaction marked with propagation 'mandatory'");
		}
		//如果事务传播特性为required、required_new或nested
		else if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||
				definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||
		    definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
			SuspendedResourcesHolder suspendedResources = suspend(null);
			if (debugEnabled) {
				logger.debug("Creating new transaction with name [" + definition.getName() + "]: " + definition);
			}
			//创建事务
			try {
				//不激活和当前线程绑定的事务，因为事务传播特性配置要求创建新的事务
				boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
				//创建一个新的事务状态
				DefaultTransactionStatus status = newTransactionStatus(
						definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
				//创建事务的调用，具体实现由具体的事务处理器提供
				doBegin(transaction, definition);
				//初始化和同步事务状态
				prepareSynchronization(status, definition);
				return status;
			}
			catch (RuntimeException ex) {
				resume(null, suspendedResources);
				throw ex;
			}
			catch (Error err) {
				resume(null, suspendedResources);
				throw err;
			}
		}
		else {
		//创建空事务，针对supported类型的事务传播特性，激活和当前线程绑定的事务
			boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
			//准备事务状态
			return prepareTransactionStatus(definition, null, true, newSynchronization, debugEnabled, null);
		}
	}
//准备事务状态
protected final DefaultTransactionStatus prepareTransactionStatus(
			TransactionDefinition definition, Object transaction, boolean newTransaction,
			boolean newSynchronization, boolean debug, Object suspendedResources) {
		//创建事务状态
		DefaultTransactionStatus status = newTransactionStatus(
				definition, transaction, newTransaction, newSynchronization, debug, suspendedResources);
		//准备事务状态
		prepareSynchronization(status, definition);
		return status;
	}
	//创建事务状态
	protected DefaultTransactionStatus newTransactionStatus(
			TransactionDefinition definition, Object transaction, boolean newTransaction,
			boolean newSynchronization, boolean debug, Object suspendedResources) {
		//判断是否是新事务，如果是新事务，则需要把事务属性存放到当前线程中
		boolean actualNewSynchronization = newSynchronization &&
		!TransactionSynchronizationManager.isSynchronizationActive();
		return new DefaultTransactionStatus(
				transaction, newTransaction, actualNewSynchronization,
				definition.isReadOnly(), debug, suspendedResources);
	}
	//初始化事务属性
	protected void prepareSynchronization(DefaultTransactionStatus status, TransactionDefinition definition) {
		if (status.isNewSynchronization()) {
		//设置当前是否有活跃事务	TransactionSynchronizationManager.setActualTransactionActive(status.hasTransaction());
		//设置当前事务隔离级别	TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(
					(definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) ?
							definition.getIsolationLevel() : null);
			TransactionSynchronizationManager.setCurrentTransactionReadOnly(definition.isReadOnly());
	//设置当前事务名称	TransactionSynchronizationManager.setCurrentTransactionName(definition.getName());
			TransactionSynchronizationManager.initSynchronization();
		}
	}

通过对上面创建事务对象的源码分析，我们看到这抽象事务管理器获取事务对象的这个模板方法主要功能是处理事务属性中配置的事务传播特性，对于判断是否存在事务的isExistingTransaction方法和创建事务对象的doBegin方法，均委派给具体的事务处理器实现。

二、抽象事务管理器AbstractPlatformTransactionManager处理已存在的事务

对于新事务的处理相对比较简单，只需根据事务属性配置创建，同时将事务隔离级别等属性保存到事务绑定的线程资源中。而对于已存在的事务处理相对比较复杂一些，在抽象事务管理器AbstractPlatformTransactionManager中通过handleExistingTransaction方法来处理已存在的事务：

private TransactionStatus handleExistingTransaction(
			TransactionDefinition definition, Object transaction, boolean debugEnabled)
			throws TransactionException {
		//如果事务传播特性为：never，则抛出异常
		if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NEVER) {
			throw new IllegalTransactionStateException(
					"Existing transaction found for transaction marked with propagation 'never'");
		}
		//如果事务传播特性是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);
			//创建非事务的事务状态，让方法非事务地执行
			return prepareTransactionStatus(
					definition