通常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的配置：

    
       
        
        
        
           
               
       
        PROPAGATION_REQUIRED,readOnly
             
         
        
        
           
               
             
         
     
    

需要配置的有三个，原始对象，事务属性和事务管理器。其中原始对象用来生成代理对象，而事务属性和事务管理器都设置到一个很重要的对象中，即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() {   // 初始化TransactionInterceptor   this.transactionInterceptor.afterPropertiesSet();   if (this.pointcut != null) {   	  // 有pointcut的生成DefaultPointcutAdvisor      return new DefaultPointcutAdvisor(this.pointcut, this.transactionInterceptor);   }   else {      // Rely on default pointcut.      // 没有pointcut的依赖默认的pointcut      return new TransactionAttributeSourceAdvisor(this.transactionInterceptor);   }}

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

TransactionAttributeSourceAdvisor.javaprivate final TransactionAttributeSourcePointcut pointcut = new TransactionAttributeSourcePointcut() {   @Override   @Nullable   protected 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对象获取是否有事务属性配置存在，来决定是否切入事务AOP   return (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
    
      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) {         @Override         public 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事务接口的交互。