【Spring】Transation：源码流程核心对象

野性酷女 2022-10-31 05:26 160阅读 0赞

# 总览 #

### 事务对象 ###

事务本质

*  还是 JDBC 的 Connection，所以事务对象最终会保存的对象还是 connection

5 层封装

*  TransationInfo
 *  TransationStatus
 *  TransationObject
 *  ConnectHolder
 *  Connection

包含关系

*  TransationInfo -> TransationStatus -> TransationObject -> ConnectHolder -> Connect

### 事务拦截器 ###

TransationInterceptor，会加入 aop 的拦截器链。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNDYwNw_size_16_color_FFFFFF_t_70]  
下一篇会详解 TransationAspectSupport。

### 事务管理器 ###

提供事务操作：比如 supend、createSavePoint、resume；commit、rollback 等

*  AbstractPlatformTransactionManager

### 事务工具类 ###

内含许多 TreadLocal 对象，因为事务必须是线程私有的，如果多个线程操作同一个事务当一个线程出现异常是否该回滚呢？

*  TransactionSynchronizationManager

public abstract class TransactionSynchronizationManager { 
 private static final Log logger = LogFactory.getLog(TransactionSynchronizationManager.class);
 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");
 
 ...

# TransationInfo #

*  `PlatformTransactionManager` 事务进行几乎所有进行时操作的核心逻辑就在这里面，它有几个子类，我们主要还是讨论 `DataSourceTransactionManager` 这个子类，也就是对 JDBC 连接的管理。
 *  `TransactionDefition` 事务在开启之前的一些配置信息，比如配置传播等级，隔离级别，超时控制等等。
 *  `TransactionStatus` 事务的运行时信息基本都在这里面，比如连接信息，挂起的事务的信息（保存点），事务跑没跑完等等。
 *  `TransactionInfo - old` ，每个 info 会包含它上个挂起事务的引用，可能为空。
 *  Joinpointxxx 这个无所谓，debug 用的，包含了事务切面的信息的一个字符串。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNDYwNw_size_16_color_FFFFFF_t_70 1][]

# 核心：TransactionStatus #

`TransactionDefinition` 基于配置，或者我们注解获取到的，其中又定义了该使用哪个 `PlatformTransactionManager`，这些相对来说都比较简单。而 `TransactionStatus` 事务运行时这个最重要的对象的创建与使用却是比较复杂的。

## 初始化三步曲 ##

它的创建大体可以分为如下流程：

## 1、创建 ##

它的创建是比较简单的，没有用工厂，直接创建即可。

public DefaultTransactionStatus(
    			@Nullable Object transaction, boolean newTransaction, boolean newSynchronization,
    			boolean readOnly, boolean debug, @Nullable Object suspendedResources) { 
    
    		this.transaction = transaction;
    		this.newTransaction = newTransaction;
    		this.newSynchronization = newSynchronization;
    		this.readOnly = readOnly;
    		this.debug = debug;
    		this.suspendedResources = suspendedResources;
    	}

transaction 是里面一个比较重要的对象，它内置了连接对象，下面是 `Transaction` 对象的获取过程：

DataSourceTransactionObject txObject = new DataSourceTransactionObject();
    	txObject.setSavepointAllowed(isNestedTransactionAllowed());
    	ConnectionHolder conHolder =
    		(ConnectionHolder) TransactionSynchronizationManager.getResource(obtainDataSource());
    	txObject.setConnectionHolder(conHolder, false);
    	return txObject;

我们可以看到核心的就是 `ConnectionHolder`，这个对象尤为重要，注意，**这里并没有建立连接，而且也可能获取到空的 `connectionHolder`，连接的包裹对象 `ConnectionHolder` 可以控制两个事物到底是不是用的同一个连接（同一个真正的事务，一起rollback 一起commit 的那种）。**

此对象存放在一个叫做 `TransactionSynchronizationManager` 的工具单例类里面，它内部持有非常多个 `ThreadLocal` 来存放事务信息。

### 2、连接初始化 ###

上面说了没有真正建立连接，建立连接是在 `doBegin()` 的方法里做的：

/** * This implementation sets the isolation level but ignores the timeout. */
    	@Override
    	protected void doBegin(Object transaction, TransactionDefinition definition) { 
    		DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
    		Connection con = null;
    		
    		// 第一步，根据是否受事务管理，或者有没有 connectionHolder 对象去创建新连接，是否获取一个新连接
    		if (!txObject.hasConnectionHolder() ||
    				txObject.getConnectionHolder().isSynchronizedWithTransaction()) { 
    			Connection newCon = obtainDataSource().getConnection();
    			if (logger.isDebugEnabled()) { 
    				logger.debug("Acquired Connection [" + newCon + "] for JDBC transaction");
    			}
    			txObject.setConnectionHolder(new ConnectionHolder(newCon), true);
    		}
    
    		// 设置此事务已经受事务管理
    		txObject.getConnectionHolder().setSynchronizedWithTransaction(true);
    		con = txObject.getConnectionHolder().getConnection();
    
    		// 设置一些 `TransactionDefinition` 过来的属性，比如隔离等级，传播等级，是否只读等等，并将其设置为可用。
    		Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);
    		txObject.setPreviousIsolationLevel(previousIsolationLevel);
    		txObject.setReadOnly(definition.isReadOnly());
    
    		// Switch to manual commit if necessary. This is very expensive in some JDBC drivers,
    		// so we don't want to do it unnecessarily (for example if we've explicitly
    		// configured the connection pool to set it already).
    		if (con.getAutoCommit()) { 
    			txObject.setMustRestoreAutoCommit(true);
    			if (logger.isDebugEnabled()) { 
    				logger.debug("Switching JDBC Connection [" + con + "] to manual commit");
    			}
    			con.setAutoCommit(false);
    		}
    
    		prepareTransactionalConnection(con, definition);
    		txObject.getConnectionHolder().setTransactionActive(true);
    
    		int timeout = determineTimeout(definition);
    		if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) { 
    			txObject.getConnectionHolder().setTimeoutInSeconds(timeout);
    		}
    		
    		//--------------------------------------------------------------------------------------
    
    		// Bind the connection holder to the thread.
    		if (txObject.isNewConnectionHolder()) { 
    			TransactionSynchronizationManager.bindResource(obtainDataSource(), txObject.getConnectionHolder());
    		}
    	}
    	}

代码很长但是很简单，从上到下依次为：

1.  如果没有 `TransactionHolder` 或者不属于其他事务管理，则创建一个新连接 `obtainDataSource().getConnection();`，并且把新创建的连接放入 `connectionHoler` 。
2.  将其设置为已经受事务同步管理 `setSynchronizedWithTransaction(true)`
3.  设置一些 `TransactionDefinition` 过来的属性，比如隔离等级，传播等级，是否只读等等，并将其设置为可用。
4.  把它塞入或者塞回 `TransactionSynchronizationManager` 的 `ThreadLocal` 里面，也就是将 `connectionHolder` 与当前线程绑定。

### 3、对 `TransactionStatus` 进行配置 ###

方法如下，非常简单，但是十分重要：

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();
    		}
    	}

我们发现又是 `TransactionSynchronizationManager`，这个事务信息保存对象不仅仅保存 `connectionHolder`，还保存它是否是一个事务，`setActualTransactionActive`，比如我们有些传播等级是有事务则使用事务，没有就不适用，spring 还是会给它准备一个 `TransactionInfo`，但是里面的实现基本上是空的。

后面是设置一些传播等级，名字，是否只读之类的属性，最后在 `initSynchronization()` 方法里面，创建了一个叫做 `synchronizations` 的 `linkedHashSet<TransactionSynchronization>`，划重点，这个东西类似一个监听器，在触发事务的某些行为时会被调用，比如被挂起，被重新使用等等：

/** * Suspend this synchronization. * Supposed to unbind resources from TransactionSynchronizationManager if managing any. * @see TransactionSynchronizationManager#unbindResource */
 	default void suspend() { 
 	}
 
 	/** * Resume this synchronization. * Supposed to rebind resources to TransactionSynchronizationManager if managing any. * @see TransactionSynchronizationManager#bindResource */
 	default void resume() { 
 	}
 
 	/** * Flush the underlying session to the datastore, if applicable: * for example, a Hibernate/JPA session. * @see org.springframework.transaction.TransactionStatus#flush() */
 	@Override
 	default void flush() { 
 	}
 	
 	/** * Invoked before transaction commit (before "beforeCompletion"). * Can e.g. flush transactional O/R Mapping sessions to the database. * This callback does not mean that the transaction will actually be committed. * A rollback decision can still occur after this method has been called. This callback * is rather meant to perform work that's only relevant if a commit still has a chance * to happen, such as flushing SQL statements to the database. * Note that exceptions will get propagated to the commit caller and cause a * rollback of the transaction. * @param readOnly whether the transaction is defined as read-only transaction * @throws RuntimeException in case of errors; will be propagated to the caller * (note: do not throw TransactionException subclasses here!) * @see #beforeCompletion */
 	default void beforeCommit(boolean readOnly) { 
 	}
 
 	/** * Invoked before transaction commit/rollback. * Can perform resource cleanup before transaction completion. * This method will be invoked after {@code beforeCommit}, even when * {@code beforeCommit} threw an exception. This callback allows for * closing resources before transaction completion, for any outcome. * @throws RuntimeException in case of errors; will be logged but not propagated * (note: do not throw TransactionException subclasses here!) * @see #beforeCommit * @see #afterCompletion */
 	default void beforeCompletion() { 
 	}

## TransactionStatus 总结 ##

我们再回顾以及总结一下 `TransactionStatus` 这个 spring 事务运行时的重要对象，成员变量以及platfromTransationManger 对其操作的重要方法如下所示，对于内嵌事务，传播等级，事务是不是同一个事物，无非就是来操作这几个方法：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNDYwNw_size_16_color_FFFFFF_t_70 2][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNDYwNw_size_16_color_FFFFFF_t_70]: /images/20221024/e5262e6cec564fe380961b600bbe0d0b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNDYwNw_size_16_color_FFFFFF_t_70 1]: /images/20221024/5759952d4c4d4e98903f925f6a629640.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNDYwNw_size_16_color_FFFFFF_t_70 2]: /images/20221024/859c17e4b9604a4abda66a1ae97a9781.png