Spring系列-Spring事务处理原理分析

介绍：
Spring既支持编程式事务处理方式，又支持声明式事务处理方式。
编程式处理方式，是我们自己通过TransactionManager的commit和rollback来实现。声明式处理方式是我们比较常用的一种，可以在xml中配置，或者通过@Transactional注解方式来使用。

事务实现原理：
事务处理模块本质是通过AOP来实现的。在配置xml的时候，我们会配置TransactionProxyFactoryBean，接下来看下相关的一些类：

TransactionProxyFactoryBean类继承自AbstractSingletonProxyFactoryBean，AbstractSingletonProxyFactoryBean又实现了InitializingBean接口，那就看下AbstractSingletonProxyFactoryBean的afterPropertiesSet方法的实现：

@Override
public void afterPropertiesSet() {
	// target不能为空
	if (this.target == null) {
		throw new IllegalArgumentException("Property 'target' is required");
	}
	// target必须是一个bean的引用
	if (this.target instanceof String) {
		throw new IllegalArgumentException("'target' needs to be a bean reference, not a bean name as value");
	}
	if (this.proxyClassLoader == null) {
		this.proxyClassLoader = ClassUtils.getDefaultClassLoader();
	}

	ProxyFactory proxyFactory = new ProxyFactory();

	if (this.preInterceptors != null) {
		for (Object interceptor : this.preInterceptors) {
			proxyFactory.addAdvisor(this.advisorAdapterRegistry.wrap(interceptor));
		}
	}

	// Add the main interceptor (typically an Advisor).
	proxyFactory.addAdvisor(this.advisorAdapterRegistry.wrap(createMainInterceptor()));

	if (this.postInterceptors != null) {
		for (Object interceptor : this.postInterceptors) {
			proxyFactory.addAdvisor(this.advisorAdapterRegistry.wrap(interceptor));
		}
	}

	proxyFactory.copyFrom(this);

	TargetSource targetSource = createTargetSource(this.target);
	proxyFactory.setTargetSource(targetSource);

	if (this.proxyInterfaces != null) {
		proxyFactory.setInterfaces(this.proxyInterfaces);
	}
	else if (!isProxyTargetClass()) {
		// Rely on AOP infrastructure to tell us what interfaces to proxy.
		proxyFactory.setInterfaces(
				ClassUtils.getAllInterfacesForClass(targetSource.getTargetClass(), this.proxyClassLoader));
	}

	postProcessProxyFactory(proxyFactory);

	this.proxy = proxyFactory.getProxy(this.proxyClassLoader);
}

这个afterPropertiesSet方法就是进行事务的AOP配置的地方，方法开始会进行一些判断，比如target不能为空，target必须是一个bean的引用等。接下来会新建一个ProxyFactory对象，配置proxyFactory的Advisor，配置目标源等操作。最后通过proxyFactory.getProxy方法，创建一个代理对象。需要注意的是在设置Advisor的时候，有个createMainInterceptor方法，注释写的是设置主要的interceptor。那就再看看这个方法，这个方法需要调用到子类TransactionProxyFactoryBean中。

private final TransactionInterceptor transactionInterceptor = new TransactionInterceptor();

@Override
protected Object createMainInterceptor() {
	this.transactionInterceptor.afterPropertiesSet();
	if (this.pointcut != null) {
		return new DefaultPointcutAdvisor(this.pointcut, this.transactionInterceptor);
	}
	else {
		// Rely on default pointcut.
		return new TransactionAttributeSourceAdvisor(this.transactionInterceptor);
	}
}

这个方法会根据场景不同，返回两种Advisor，DefaultPointcutAdvisor或TransactionAttributeSourceAdvisor，并且会把transactionInterceptor设置进去。这个transactionInterceptor就是就是实现事务的拦截器。接下来再看下TransactionAttributeSourceAdvisor这个类。

public class TransactionAttributeSourceAdvisor extends AbstractPointcutAdvisor {

	private TransactionInterceptor transactionInterceptor;

	private final TransactionAttributeSourcePointcut pointcut = new TransactionAttributeSourcePointcut() {
		@Override
		protected TransactionAttributeSource getTransactionAttributeSource() {
			return (transactionInterceptor != null ? transactionInterceptor.getTransactionAttributeSource() : null);
		}
	};

}

这个Advisor定义了Advice是TransactionInterceptor，Pointcut是TransactionAttributeSourcePointcut，这个TransactionAttributeSourcePointcut就是判断一个调用是否需要触发事务处理的，看下TransactionAttributeSourcePointcut的实现：

@Override
public boolean matches(Method method, Class targetClass) {
	if (TransactionalProxy.class.isAssignableFrom(targetClass)) {
		return false;
	}
	TransactionAttributeSource tas = getTransactionAttributeSource();
	return (tas == null || tas.getTransactionAttribute(method, targetClass) != null);
}

方法中有个matches方法，用来进行条件判断。这里用到的TransactionAttributeSource是NameMatchTransactionAttributeSource，具体不再详细说明，感兴趣的可以自己研究下。

由于在AbstractSingletonProxyFactoryBean中，设置了代理类，在对方法调用时，会调用到代理类设置的拦截器，也就是TransactionInterceptor，下面看下TransactionInterceptor的实现，可以看到有invoke方法，来执行回调：

@Override
public Object invoke(final MethodInvocation invocation) throws Throwable {
	// Work out the target class: may be {@code null}.
	// The TransactionAttributeSource should be passed the target class
	// as well as the method, which may be from an interface.
	Class targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);

	// Adapt to TransactionAspectSupport's invokeWithinTransaction...
	return invokeWithinTransaction(invocation.getMethod(), targetClass, new InvocationCallback() {
		@Override
		public Object proceedWithInvocation() throws Throwable {
			return invocation.proceed();
		}
	});
}

这个方法，调用了invokeWithinTransaction方法：

/**
 * General delegate for around-advice-based subclasses, delegating to several other template
 * methods on this class. Able to handle {@link CallbackPreferringPlatformTransactionManager}
 * as well as regular {@link PlatformTransactionManager} implementations.
 * @param method the Method being invoked
 * @param targetClass the target class that we're invoking the method on
 * @param invocation the callback to use for proceeding with the target invocation
 * @return the return value of the method, if any
 * @throws Throwable propagated from the target invocation
 */
protected Object invokeWithinTransaction(Method method, Class targetClass, final InvocationCallback invocation)
		throws Throwable {

	// If the transaction attribute is null, the method is non-transactional.
	final TransactionAttribute txAttr = getTransactionAttributeSource().getTransactionAttribute(method, targetClass);
	// 根据配置信息获取具体的事务处理器
	final PlatformTransactionManager tm = determineTransactionManager(txAttr);
	final String joinpointIdentification = methodIdentification(method, targetClass);

	// 不同的PlatformTransactionManager，处理逻辑不一样，区分CallbackPreferringPlatformTransactionManager类型和非CallbackPreferringPlatformTransactionManager类型的
	if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {
		// Standard transaction demarcation with getTransaction and commit/rollback calls.
		TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
		Object retVal = null;
		try {
			// This is an around advice: Invoke the next interceptor in the chain.
			// This will normally result in a target object being invoked.
			retVal = invocation.proceedWithInvocation();
		}
		catch (Throwable ex) {
			// target invocation exception
			completeTransactionAfterThrowing(txInfo, ex);
			throw ex;
		}
		finally {
			cleanupTransactionInfo(txInfo);
		}
		// 通过事务处理器提交事务
		commitTransactionAfterReturning(txInfo);
		return retVal;
	}

	else {
		// It's a CallbackPreferringPlatformTransactionManager: pass a TransactionCallback in.
		// 通过回调方法来使用事务处理器。
		try {
			Object result = ((CallbackPreferringPlatformTransactionManager) tm).execute(txAttr,
					new TransactionCallback