Spring事务源码分析

public final TransactionStatus getTransaction(TransactionDefinition definition){
if (isExistingTransaction(transaction)) {
    // 如果当前上下文存在事务 -> 检查用户设置的隔离级别来确定当前事务的行为
    return handleExistingTransaction(definition, transaction, debugEnabled);
}
// PROPAGATION_MANDATORY级别不存在当前事务,抛异常.
if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
	throw new IllegalTransactionStateException(
			"No existing transaction found for transaction marked with propagation 'mandatory'");
}
//需要支持事务
else if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||
		definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||
		definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
	//把当前事务挂起并保存当前事务的事务属性
	SuspendedResourcesHolder suspendedResources = suspend(null);
	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 | Error ex) {
		resume(null, suspendedResources);
		throw ex;
	}
}
else {
	// 其他事务级别以非事务方式执行
	if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {
		logger.warn("Custom isolation level specified but no actual transaction initiated; " +
				"isolation level will effectively be ignored: " + definition);
	}
	boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
	return prepareTransactionStatus(definition, null, true, newSynchronization, debugEnabled, null);
}
}

protected final SuspendedResourcesHolder suspend(Object transaction) throws TransactionException {
//当前事务开启了事务同步
if (TransactionSynchronizationManager.isSynchronizationActive()) {
    //把当前事务的所有事务同步器挂起
	List<TransactionSynchronization> suspendedSynchronizations = doSuspendSynchronization();
	try {
		Object suspendedResources = null;
		if (transaction != null) {
			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;
	}
}
//没有开启同步但存在事务,则调用对应TransactionManager的doSuspend()方法挂起事务
else if (transaction != null) {
	// Transaction active but no synchronization active.
	Object suspendedResources = doSuspend(transaction);
	return new SuspendedResourcesHolder(suspendedResources);
}
else {
	// 不存在事务也没有开启事务同步
	return null;
}
	}

public abstract class TransactionSynchronizationManager {
//线程绑定的资源,比如DataSourceTransactionManager绑定是的某个数据源的一个Connection,在整个事务执行过程中
//都使用同一个Jdbc Connection
private static final ThreadLocal<Map<Object, Object>> resources =
		new NamedThreadLocal<>("Transactional resources");
//事务注册的事务同步器
private static final ThreadLocal<Set<TransactionSynchronization>> synchronizations =
		new NamedThreadLocal<>("Transaction synchronizations");
//事务名称
private static final ThreadLocal<String> currentTransactionName =
		new NamedThreadLocal<>("Current transaction name");
//事务只读属性
private static final ThreadLocal<Boolean> currentTransactionReadOnly =
		new NamedThreadLocal<>("Current transaction read-only status");
//事务隔离级别
private static final ThreadLocal<Integer> currentTransactionIsolationLevel =
		new NamedThreadLocal<>("Current transaction isolation level");
//事务同步开启
private static final ThreadLocal<Boolean> actualTransactionActive =
		new NamedThreadLocal<>("Actual transaction active");
}

protected void doBegin(Object transaction, TransactionDefinition definition) {
DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
Connection con = null;

try {
	if (!txObject.hasConnectionHolder() ||
			txObject.getConnectionHolder().isSynchronizedWithTransaction()) {
		//从数据源中获取一个连接
		Connection newCon = obtainDataSource().getConnection();
		txObject.setConnectionHolder(new ConnectionHolder(newCon), true);
	}

	txObject.getConnectionHolder().setSynchronizedWithTransaction(true);
	con = txObject.getConnectionHolder().getConnection();

	Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);
	txObject.setPreviousIsolationLevel(previousIsolationLevel);

	// 关闭Connection的自动提交,由Spring框架来控制事务的提交和回滚,
	 //修改自动提交操作代价非常大,先做判断是否开启了自动提交然后再修改
	if (con.getAutoCommit()) {
		txObject.setMustRestoreAutoCommit(true);
		con.setAutoCommit(false);
	}

	prepareTransactionalConnection(con, definition);
	txObject.getConnectionHolder().setTransactionActive(true);
    //根据事务定义的超时时间来设置事务的超时时间
	int timeout = determineTimeout(definition);
	if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
		txObject.getConnectionHolder().setTimeoutInSeconds(timeout);
	}

	//将ConnectionHolder对象绑定到事务同步管理器中
	if (txObject.isNewConnectionHolder()) {
		TransactionSynchronizationManager.bindResource(obtainDataSource(), txObject.getConnectionHolder());
	}
}

catch (Throwable ex) {
	if (txObject.isNewConnectionHolder()) {
		DataSourceUtils.releaseConnection(con, this.dataSource);
		txObject.setConnectionHolder(null, false);
	}
	throw new CannotCreateTransactionException("Could not open JDBC Connection for transaction", ex);
}
}