通常Spring事务管理的配置都是XML或者声明式注解的方式，然后想要学习其运行的原理，从TransactionProxyFactoryBean深入更合适。我们从事务相关的核心类开始，逐步介绍Spring事务的运行机制。

Spring事务核心类

Spring事务的构成，基本有三个部分，事务属性的定义，事务对象及状态信息的持有，事务管理器的处理。

事务属性的定义

1. TransactionDefinition 事务定义（传播属性，隔离属性，timeout等）
2. TransactionAttribute 事务属性接口 （继承TransactionDefinition），常用的实现是RuleBasedTransactionAttribute
3. TransactionAttributeSource 事务属性数据源，可以根据method和Class获取TransactionAttribute（注解方式的实现为AnnotationTransactionAttributeSource，编程方式的实现为NameMatchTransactionAttributeSource）

事务对象及状态信息的持有

1. Transaction 事务对象，由具体的事务管理器实现返回
2. TransactionStatus 事务状态，持有事务对象以及事务本身的属性及状态，每次事务方法执行前，生成一个新的TransactionStatus，但如果不需要创建新事务，则持有的事务和上层一致
3. TransactionInfo 事务信息，持有事务属性，事务状态，事务连接点（方法路径），事务管理器，每次事务方法执行，生成新的TransactionInfo，并且绑定到当前线程（ThreadLocal），同时持有上一事务信息对象，形成链式结构。

事务管理器的处理

1. PlatformTransactionManager事务管理接口，AbstractPlatformTransactionManager为其抽象实现（实现了getTransaction，commit，rollback模板方法），常用的实现如JDBC的事务管理实现DataSourceTransactionManager

TransactionProxyFactoryBean

TransactionProxyFactoryBean实现了FactoryBean和InitializingBean接口，FactoryBean支持对需要事务支持的类的代理，InitializingBean初始化事务环境的准备工作，完成代理对象的创建。我们再来看下xml的配置：

<!-- userManager事务代理类 -->
<bean id="userManagerTransactionProxy"class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"><!-- 原始对象 --><property name="target" ref="userManager"/><!-- 事务属性 --><property name="transactionAttributes"><props><prop key="batchOperator">PROPAGATION_REQUIRED,readOnly</prop></props></property><!-- 事务管理器 --><property name="transactionManager"><bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager"><property name="dataSource" ref="dataSource"/></bean></property>
</bean>

需要配置的有三个，原始对象，事务属性和事务管理器。其中原始对象用来生成代理对象，而事务属性和事务管理器都设置到一个很重要的对象中，即TransactionInterceptor，事务拦截器，对应AOP中的增强类，完成事务管理和方法本身的结合。

回到TransactionProxyFactoryBean的构造，其主要实现定义在抽象父类AbstractSingletonProxyFactoryBean中。在初始化方法afterPropertiesSet中，使用最原始的ProxyFactory， 完成了代理对象的创建。

AbstractSingletonProxyFactoryBean.javapublic void afterPropertiesSet() {if (this.target == null) {throw new IllegalArgumentException("Property 'target' is required");}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();}// 创建AOP代理工厂ProxyFactory proxyFactory = new ProxyFactory();// 添加前置增强拦截器if (this.preInterceptors != null) {for (Object interceptor : this.preInterceptors) {proxyFactory.addAdvisor(this.advisorAdapterRegistry.wrap(interceptor));}}// 核心增强拦截器，有子类实现，在TransactionProxyFactoryBean中即是TransactionInterceptor// 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));}}// 拷贝AOP的基本配置，如exposeProxy等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.Class<?> targetClass = targetSource.getTargetClass();if (targetClass != null) {proxyFactory.setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader));}}// 对proxyFactory的后置处理postProcessProxyFactory(proxyFactory);// 代理工厂生成代理对象this.proxy = proxyFactory.getProxy(this.proxyClassLoader);
}

其中核心增强拦截器有子类实现其创建方法createMainInterceptor

TransactionProxyFactoryBean.javaprotected Object createMainInterceptor() {// 初始化TransactionInterceptorthis.transactionInterceptor.afterPropertiesSet();if (this.pointcut != null) {// 有pointcut的生成DefaultPointcutAdvisorreturn new DefaultPointcutAdvisor(this.pointcut, this.transactionInterceptor);}else {// Rely on default pointcut.// 没有pointcut的依赖默认的pointcutreturn new TransactionAttributeSourceAdvisor(this.transactionInterceptor);}
}

TransactionAttributeSourceAdvisor的默认pointcut类是TransactionAttributeSourcePointcut，定义在其内部。

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

TransactionAttributeSourcePointcut是一个抽象类，在TransactionAttributeSourceAdvisor匿名实现的。我们来看下TransactionAttributeSourcePointcut的实现，它继承了StaticMethodMatcherPointcut，一个对方法进行匹配的基本Pointcut类，实现matches方法。

public boolean matches(Method method, @Nullable Class<?> targetClass) {if (targetClass != null && TransactionalProxy.class.isAssignableFrom(targetClass)) {return false;}// 获取事务属性数据源TransactionAttributeSource tas = getTransactionAttributeSource();// 根据方法和Class对象获取是否有事务属性配置存在，来决定是否切入事务AOPreturn (tas == null || tas.getTransactionAttribute(method, targetClass) != null);
}

而事务属性数据源从哪里设置的呢？我们在上面的TransactionAttributeSourceAdvisor匿名实现的TransactionAttributeSourcePointcut类中可以发现TransactionAttributeSource是从TransactionInterceptor中获取的。而TransactionInterceptor的TransactionAttributeSource是哪里设置的呢？来源于XML配置的properties对象transactionAttributes，在TransactionProxyFactoryBean的setTransactionAttributes方法中。

public void setTransactionAttributes(Properties transactionAttributes) {this.transactionInterceptor.setTransactionAttributes(transactionAttributes);
}

transactionAttributes实际被设置到TransactionInterceptor中

public void setTransactionAttributes(Properties transactionAttributes) {NameMatchTransactionAttributeSource tas = new NameMatchTransactionAttributeSource();tas.setProperties(transactionAttributes);this.transactionAttributeSource = tas;
}

这里看到TransactionAttributeSource的实现是NameMatchTransactionAttributeSource。在其内部维护了一个方法名和事务属性的Map

private Map<String, TransactionAttribute> nameMap = new HashMap<>();

因此对哪个方法进行事务AOP的切入的原理就很清楚了。接下来就是核心拦截器TransactionInterceptor的解析。

TransactionInterceptor

TransactionInterceptor实现了Spring AOP的基本增加接口MethodInterceptor，实现invoke方法

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, invocation::proceed);
}

具体实现由TransactionInterceptor抽象子类TransactionAspectSupport的invokeWithinTransaction方法执行

protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,final InvocationCallback invocation) throws Throwable {// If the transaction attribute is null, the method is non-transactional.// 获取事务属性数据源，如果为null，则此方法为非事务环境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);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中为方法本身的执行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;}// ...

这个方法就是事务执行的核心部分，通过环绕增加，完成方法不同执行结果(成功或异常)对应事务的处理。当然前提是要先创建事务，来看createTransactionIfNecessary方法

protected TransactionInfo createTransactionIfNecessary(@Nullable PlatformTransactionManager tm,@Nullable TransactionAttribute txAttr, final String joinpointIdentification) {// If no name specified, apply method identification as transaction name.if (txAttr != null && txAttr.getName() == null) {txAttr = new DelegatingTransactionAttribute(txAttr) {@Overridepublic String getName() {return joinpointIdentification;}};}TransactionStatus status = null;if (txAttr != null) {if (tm != null) {// 由事务管理器创建事务状态对象status = tm.getTransaction(txAttr);}else {if (logger.isDebugEnabled()) {logger.debug("Skipping transactional joinpoint [" + joinpointIdentification +"] because no transaction manager has been configured");}}}// 填充事务状态对象的其他信息return prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
}

事务对象及状态的维护由具体的事务管理器来管理，下一章我们具体讨论事务管理器，这里主要关注它的构建骨架。返回的事务状态对象TransactionStatus，需要再次被prepareTransactionInfo方法填充

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);}else {if (logger.isTraceEnabled())logger.trace("Don't need to create transaction for [" + joinpointIdentification +"]: This method isn't transactional.");}// We always bind the TransactionInfo to the thread, even if we didn't create// a new transaction here. This guarantees that the TransactionInfo stack// will be managed correctly even if no transaction was created by this aspect.// 绑定事务信息对象和当前线程，并在当前事务信息对象中记录线程原来绑定的事务信息对象，从而保证了事务信息栈的管理txInfo.bindToThread();return txInfo;
}

这里非常重要的是维护了一个线程级别的事务信息的栈结构。

事务信息组建完成后，就是方法本身的执行。如果发生异常，则事务该如何处理，由completeTransactionAfterThrowing方法执行

protected void completeTransactionAfterThrowing(@Nullable TransactionInfo txInfo, Throwable ex) {if (txInfo != null && txInfo.getTransactionStatus() != null) {if (logger.isTraceEnabled()) {logger.trace("Completing transaction for [" + txInfo.getJoinpointIdentification() +"] after exception: " + ex);}// 校验当前异常是否要回滚事务，如果是，则执行回滚操作，如果不是，则执行提交操作if (txInfo.transactionAttribute != null && txInfo.transactionAttribute.rollbackOn(ex)) {try {txInfo.getTransactionManager().rollback(txInfo.getTransactionStatus());}catch (TransactionSystemException ex2) {logger.error("Application exception overridden by rollback exception", ex);ex2.initApplicationException(ex);throw ex2;}catch (RuntimeException ex2) {logger.error("Application exception overridden by rollback exception", ex);throw ex2;}catch (Error err) {logger.error("Application exception overridden by rollback error", ex);throw err;}}else {// We don't roll back on this exception.// Will still roll back if TransactionStatus.isRollbackOnly() is true.try {txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());}catch (TransactionSystemException ex2) {logger.error("Application exception overridden by commit exception", ex);ex2.initApplicationException(ex);throw ex2;}catch (RuntimeException ex2) {logger.error("Application exception overridden by commit exception", ex);throw ex2;}catch (Error err) {logger.error("Application exception overridden by commit error", ex);throw err;}}}
}

在上面的方法中，核心就是判断原始方法抛出的异常是否要回滚事务，如果是，则调用事务管理器回滚事务，如果不是，则直接提交事务。

对异常是否回滚事务的判断是由事务属性中的rollbackFor和noRollbackFor共同决定的，默认都没有配置时，执行DefaultTransactionAttribute基本事务属性类中的rollbackOn方法

public boolean rollbackOn(Throwable ex) {return (ex instanceof RuntimeException || ex instanceof Error);
}

即当异常为运行时异常或Error时，就会回滚，否则直接提交。直接提交这一点也是需要格外注意的。

如果方法运行没有异常，执行完成后，就需要提交事务，由commitTransactionAfterReturning方法执行

protected void commitTransactionAfterReturning(@Nullable TransactionInfo txInfo) {if (txInfo != null && txInfo.getTransactionStatus() != null) {if (logger.isTraceEnabled()) {logger.trace("Completing transaction for [" + txInfo.getJoinpointIdentification() + "]");}txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());}
}

调用事务管理器执行commit来提交事务。

至此，对于TransactionProxyFactoryBean的AOP代理生成以及TransactionInterceptor核心增强中事务执行的原理都基本解析清楚了，下一章介绍事务管理器的运行机制以及DataSourceTransactionManager如何和JDBC事务接口的交互。