TransactionDefinition——事务定义

定义事务属性，包括传播级别、隔离级别、名称、超时、只读等

TransactionStatus——事务状态

事务状态，包含事务对象（jdbc为DataSourceTransactionObject），是否新事务、是否新同步对象、是否只读、是否回滚、是否完成、事务中断对象（SuspendedResourcesHolder实现事务中断，保存中断事务的信息）、保存点对象（jdbc为Savepoint，实现嵌套事务）

DataSourceTransactionObject——事务对象

jdbc中事务对象。

持有一个ConnectionHolder对象，而ConnectionHolder持有Connection对象。

SuspendedResourcesHolder——中断事务对象

用于实现事务挂起，持有一个中断事务suspendedResources（jdbc为ConnectionHolder），中断同步对象集合suspendedSynchronizations。

SavePoint——保存点

保存点用于实现嵌套事务，只有jdbc才有

TransactionManger——事务管理器

AbstractPlatformTransactionManager：实现事务的获取、提交、回滚等主要逻辑

传播级别——Propagation

PROPAGATION_REQUIRED：支持当前事务，没有事务开启事务
PROPAGATION_SUPPORTS：支持当前事务，没有事务非事务运行
PROPAGATION_MANDATORY：支持当前事务，没有事务报错
PROPAGATION_REQUIRES_NEW：有事务挂起事务，新建事务
PROPAGATION_NOT_SUPPORTED：有事务挂起事务，非事务执行
PROPAGATION_NEVER：有事务报错
PROPAGATION_NESTED：嵌套事务，外层事务回滚，内层也回滚

getTransaction——获取事务

public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition)

			throws TransactionException {

		TransactionDefinition def = (definition != null ? definition : TransactionDefinition.withDefaults());

    	//1.封装transaction对象并获取当前事务的ConnectionHolder

		Object transaction = doGetTransaction();

    	//2.当前存在事务，根据事务传播级别处理

		if (isExistingTransaction(transaction)) {

			return handleExistingTransaction(def, transaction, debugEnabled);

		}

		if (def.getTimeout() < TransactionDefinition.TIMEOUT_DEFAULT) {

			throw new InvalidTimeoutException("Invalid transaction timeout", def.getTimeout());

		}

    	//3.当前不存在事务，根据不同事务传播级别处理

    	//3.1. 如果传播级别是PROPAGATION_MANDATORY，不存在事务报错

		if (def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {

			throw new IllegalTransactionStateException(

					"No existing transaction found for transaction marked with propagation 'mandatory'");

		}

    	//3.2. 如果传播级别是PROPAGATION_REQUIRED、PROPAGATION_REQUIRES_NEW、PROPAGATION_NESTED

		else if (def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||

				def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||

				def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {

            //3.2.1. 中断事务同步管理器中注册的同步对象，封装中断事务对象

			SuspendedResourcesHolder suspendedResources = suspend(null);

			try {

                //3.2.2. 开启新事务

				return startTransaction(def, transaction, debugEnabled, suspendedResources);

			}

			catch (RuntimeException | Error ex) {

                //3.2.3. 开启新事务失败，重启中断事务对象中的同步对象

				resume(null, suspendedResources);

				throw ex;

			}

		}

    	//3.3. 其他传播级别，以非事务执行代码，但还是封装TransactionStatus返回

		else {

			boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);

			return prepareTransactionStatus(def, 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);

			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 {

				return startTransaction(definition, transaction, debugEnabled, suspendedResources);

			}

			catch (RuntimeException | Error beginEx) {

				resumeAfterBeginException(transaction, suspendedResources, beginEx);

				throw beginEx;

			}

		}

    	//传播级别为PROPAGATION_NESTED，jdbc处理为在当前事务上创建一个保存点

		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()) {

				DefaultTransactionStatus status =

						prepareTransactionStatus(definition, transaction, false, false, debugEnabled, null);

				status.createAndHoldSavepoint();

				return status;

			}

			else {

				// JTA事务的处理

				return startTransaction(definition, transaction, debugEnabled, null);

			}

		}

		// 传播级别为PROPAGATION_SUPPORTS、PROPAGATION_REQUIRED以当前事务执行

		//省略代码。。。

		boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);

		return prepareTransactionStatus(definition, transaction, false, newSynchronization, debugEnabled, null);

	}

commit——提交事务

public final void commit(TransactionStatus status) throws TransactionException {

		//1.TransactionStatus设置了回滚，执行回滚操作

		DefaultTransactionStatus defStatus = (DefaultTransactionStatus) status;

		if (defStatus.isLocalRollbackOnly()) {

			if (defStatus.isDebug()) {

				logger.debug("Transactional code has requested rollback");

			}

			processRollback(defStatus, false);

			return;

		}

		//2.TransactionStatus的ConnectionHolder设置了回滚，执行回滚操作

		if (!shouldCommitOnGlobalRollbackOnly() && defStatus.isGlobalRollbackOnly()) {

			if (defStatus.isDebug()) {

				logger.debug("Global transaction is marked as rollback-only but transactional code requested commit");

			}

			processRollback(defStatus, true);

			return;

		}

		//3.执行提交操作

		processCommit(defStatus);

	}

processCommit方法：

private void processCommit(DefaultTransactionStatus status) throws TransactionException {

		try {

			boolean beforeCompletionInvoked = false;

			try {

				boolean unexpectedRollback = false;

				prepareForCommit(status);

                //触发TransactionSynchronization的beforeCommit和beforeCompletion

				triggerBeforeCommit(status);

				triggerBeforeCompletion(status);

				beforeCompletionInvoked = true;

                //有保存点，即嵌套事务，释放保存点

				if (status.hasSavepoint()) {

					if (status.isDebug()) {

						logger.debug("Releasing transaction savepoint");

					}

					unexpectedRollback = status.isGlobalRollbackOnly();

					status.releaseHeldSavepoint();

				}

                //如果是事务最外层，提交事务

				else if (status.isNewTransaction()) {

					if (status.isDebug()) {

						logger.debug("Initiating transaction commit");

					}

					unexpectedRollback = status.isGlobalRollbackOnly();

					doCommit(status);

				}

                //默认为false

				else if (isFailEarlyOnGlobalRollbackOnly()) {

					unexpectedRollback = status.isGlobalRollbackOnly();

				}

				if (unexpectedRollback) {

					throw new UnexpectedRollbackException(

							"Transaction silently rolled back because it has been marked as rollback-only");

				}

			}

			catch (UnexpectedRollbackException ex) {

				// can only be caused by doCommit

                //触发TransactionSynchronization的afterCompletion

				triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK);

				throw ex;

			}

			catch (TransactionException ex) {

				// can only be caused by doCommit

                //默认为false

				if (isRollbackOnCommitFailure()) {

					doRollbackOnCommitException(status, ex);

				}

				else {

                    //触发TransactionSynchronization的afterCompletion

					triggerAfterCompletion(status, TransactionSynchronization.STATUS_UNKNOWN);

				}

				throw ex;

			}

			catch (RuntimeException | Error ex) {

                //是否触发过TransactionSynchronization的beforeCompletion

				if (!beforeCompletionInvoked) {

					triggerBeforeCompletion(status);

				}

                //回滚事务

				doRollbackOnCommitException(status, ex);

				throw ex;

			}

			//触发TransactionSynchronization的afterCommit和afterCompletion

			try {

				triggerAfterCommit(status);

			}

			finally {

				triggerAfterCompletion(status, TransactionSynchronization.STATUS_COMMITTED);

			}

		}

		finally {

            //有中断事务恢复中断事务，没有重置TransactionSynchronizationManager

			cleanupAfterCompletion(status);

		}

	}

rollback——回滚事务

public final void rollback(TransactionStatus status) throws TransactionException {

		DefaultTransactionStatus defStatus = (DefaultTransactionStatus) status;

		processRollback(defStatus, false);

	}

processRollback方法：

private void processRollback(DefaultTransactionStatus status, boolean unexpected) {

		try {

			boolean unexpectedRollback = unexpected;

			try {

                //触发TransactionSynchronization的beforeCompletion

				triggerBeforeCompletion(status);

                //有保存点，即嵌套事务，回滚到保存点

				if (status.hasSavepoint()) {

					if (status.isDebug()) {

						logger.debug("Rolling back transaction to savepoint");

					}

					status.rollbackToHeldSavepoint();

				}

                //如果是事务最外层，回滚事务

				else if (status.isNewTransaction()) {

					if (status.isDebug()) {

						logger.debug("Initiating transaction rollback");

					}

					doRollback(status);

				}

				else {

					// 如果事务标记为回滚，将ConnectionHolder标记为回滚

					if (status.hasTransaction()) {

						if (status.isLocalRollbackOnly() || isGlobalRollbackOnParticipationFailure()) {

							doSetRollbackOnly(status);

						}

					}

					// Unexpected rollback only matters here if we're asked to fail early

					if (!isFailEarlyOnGlobalRollbackOnly()) {

						unexpectedRollback = false;

					}

				}

			}

			catch (RuntimeException | Error ex) {

                //触发TransactionSynchronization的afterCompletion

				triggerAfterCompletion(status, TransactionSynchronization.STATUS_UNKNOWN);

				throw ex;

			}

            //触发TransactionSynchronization的afterCompletion

			triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK);

			// Raise UnexpectedRollbackException if we had a global rollback-only marker

			if (unexpectedRollback) {

				throw new UnexpectedRollbackException(

						"Transaction rolled back because it has been marked as rollback-only");

			}

		}

		finally {

            //有中断事务恢复中断事务，没有重置TransactionSynchronizationManager

			cleanupAfterCompletion(status);

		}

	}

巴特西

spring tx——TransactionManger