Spring之执行事务流程

上一篇文章我们已经对配置文件进行了解析，对bean的实例化过程也和之前的差不多，就不再分析了，我们这次主要的任务就是看一下事务是怎么在Spring中执行的：

userService.save();
userService.update();

这两行代码是展开本文的入口：

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		MethodInvocation invocation;
		...
	}

由于我们在配置事务AOP的时候，让他扫描了service所在的包，所以，在创建UserService 的时候添加到IOC容器中的是它的 代理类，所以在执行它的save方法的时候直接进入了invoke方法：

List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

获得针对这个方法的所有拦截器

[org.springframework.aop.interceptor.ExposeInvocationInterceptor@74bada02, 
org.springframework.transaction.interceptor.TransactionInterceptor@525575]

发现有两个，一个是自动添加的拦截器，另外一个就是有关事务的拦截器了

invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);

将这个代理类的一些信息封装成MethodInvocation

retVal = invocation.proceed();

开始从拦截器链的头部开始执行，我们直接跳到事务的那个拦截器的处理逻辑上：

public Object invoke(final MethodInvocation invocation) throws Throwable {
		// 获得目标类的class对象
		Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);
		return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed);
	}

这个方法首先获得了目标类的class对象，然后开始执行invokeWithinTransaction，由于这个方法比较长，像以前一样，我们一部分一部分的执行：

//获得事务的封装对象
TransactionAttributeSource tas = getTransactionAttributeSource();
//获得当前方法的事务属性
final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);
//获得事务管理类，这个主要是根据我们选择的数据源有关的
final PlatformTransactionManager tm = determineTransactionManager(txAttr);
//获得方法完整的限定名
final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);

这段代码针对当前方法获得了事务的属性，方法的限定名，和事务管理类

TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);

根据给定的TransactionAttribute创建一个事务，下面是这个方法完整的代码：

protected TransactionInfo createTransactionIfNecessary(@Nullable PlatformTransactionManager tm,
			@Nullable TransactionAttribute txAttr, final String joinpointIdentification) {

		// 如果没有指定名称，则应用方法标识作为事务名称。
		if (txAttr != null && txAttr.getName() == null) {
			//封装事务的属性
			txAttr = new DelegatingTransactionAttribute(txAttr) {
				@Override
				public String getName() {
					return joinpointIdentification;
				}
			};
		}

		TransactionStatus status = null;
		if (txAttr != null) {
			if (tm != null) {
				//获得当前事务的状态
				status = tm.getTransaction(txAttr);
			}
			...
		}
		return prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
	}

我们继续看一下TransactionStatus 对象是怎么获取到的：

Object transaction = doGetTransaction();

首先执行了这个方法：

protected Object doGetTransaction() {
		//获取数据源的事务对象
		DataSourceTransactionObject txObject = new DataSourceTransactionObject();
		//设置回滚点
		txObject.setSavepointAllowed(isNestedTransactionAllowed());
		//获得封装连接的对象
		ConnectionHolder conHolder =
				(ConnectionHolder) TransactionSynchronizationManager.getResource(obtainDataSource());
		//填充属性
		txObject.setConnectionHolder(conHolder, false);
		return txObject;
	}

这个方法创建了一个数据源的事务对象

//是否需要同步
boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
//封装DefaultTransactionStatus
DefaultTransactionStatus status = newTransactionStatus(definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
//开始执行事务
doBegin(transaction, definition);
prepareSynchronization(status, definition);
return status;

我们终于看到了要开始执行事务了，走进doBegin看一下：

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();
				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();
			//获得隔离级别
			Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);
			txObject.setPreviousIsolationLevel(previousIsolationLevel);

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

			// 将连接绑定到线程。
			if (txObject.isNewConnectionHolder()) {
				TransactionSynchronizationManager.bindResource(obtainDataSource(), txObject.getConnectionHolder());
			}
		}

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

在这个方法中设置了事务的属性并开启了事务

protected TransactionInfo prepareTransactionInfo(@Nullable PlatformTransactionManager tm,
			@Nullable TransactionAttribute txAttr, String joinpointIdentification,
			@Nullable TransactionStatus status) {
		//实例化一个新的当前事务的信息
		TransactionInfo txInfo = new TransactionInfo(tm, txAttr, joinpointIdentification);
		if (txAttr != null) {			
			//添加当前事务的状态
			txInfo.newTransactionStatus(status);
		}
	

		// 绑定当前线程
		txInfo.bindToThread();
		return txInfo;
	}

创建了当前事务的信息，最终返回到了这个方法中invokeWithinTransaction，接下来的程序都是运行在事务开启环境当中的：

retVal = invocation.proceedWithInvocation();

进入这个方法后由于拦截器已经执行完了，所以下面执行的是目标方法

invokeJoinpoint();

添加事务后，我们发现其实和以前讲AOP的流程没有什么差别，无非是在事务的拦截器中开启了事务，目标方法结束后提交了事务。