1.Spring事务处理的基本过程：

Spring事务处理主要分以下三个主要的过程：

(1).读取和处理在Spring IoC容器中配置的事务处理属性，并转化为Spring事务处理所需要的内部数据结构。

(2).Spring事务处理模块实现的统一的事务处理过程。这个通用的事务处理过程包括：处理事务配置属性；事务配置属性与线程绑定等。

(3).底层事务处理实现。Spring中底层事务处理的实现交由PlatformTransactionManager的具体实现类来实现，如DataSourceTransactionManager和HibernateTransactionManager等。

接下来，将分三篇文章分别针对Spring事务处理这三个过程进行源码分析，本文首先分析读取和处理在Spring IoC容器中配置的事务处理属性的过程。

2.Spring管理事务处理的IoC容器—TransactionProxyFactoryBean：

TransactionProxyFactoryBean是Spring中管理事务的IoC容器，它通过Spring的AOP功能来完成事务管理配置。TransactionProxyFactoryBean为Spring的事务处理的实现做准备工作，包括配置AOP的***、通知器；同时向TransactionProxyFactoryBean注入事务处理器和事务处理属性等。TransactionProxyFactoryBean源码如下：

[java]  view plain copy
  1. public class TransactionProxyFactoryBean extends AbstractSingletonProxyFactoryBean  
  2.         implements BeanFactoryAware {  
  3.     //通过AOP发挥作用的事务***  
  4.     private final TransactionInterceptor transactionInterceptor = new TransactionInterceptor();  
  5.     //事务的AOP切入点  
  6.     private Pointcut pointcut;  
  7.     //通过Spring IoC容器依赖注入的PlatformTransactionManager事务管理器  
  8.     public void setTransactionManager(PlatformTransactionManager transactionManager) {  
  9.     this.transactionInterceptor.setTransactionManager(transactionManager);  
  10.     }  
  11.     //通过依赖注入设置事务属性，以Properties形式存放的事务属性的key是方法名，  
  12.     //value是事务属性描述  
  13.     public void setTransactionAttributes(Properties transactionAttributes) {  
  14.     this.transactionInterceptor.setTransactionAttributes(transactionAttributes);  
  15.     }  
  16.     //通过依赖注入设置事务属性源，通过事务属性源可以找到需要使用的事务属性  
  17.     public void setTransactionAttributeSource(TransactionAttributeSource transactionAttributeSource) {  
  18.     this.transactionInterceptor.setTransactionAttributeSource(transactionAttributeSource);  
  19.     }  
  20.     //通过依赖注入设置事务切入点，事务切入点根据触发条件调用事务***  
  21.     public void setPointcut(Pointcut pointcut) {  
  22.         this.pointcut = pointcut;  
  23.     }  
  24.     //为事务***设置管理事务的容器  
  25.     public void setBeanFactory(BeanFactory beanFactory) {  
  26.         this.transactionInterceptor.setBeanFactory(beanFactory);  
  27.     }  
  28. //创建Spring AOP事务处理的通知器Advisor  
  29.     protected Object createMainInterceptor() {  
  30.         //调用事务***的方法，检查必需的属性是否设置  
  31.         this.transactionInterceptor.afterPropertiesSet();  
  32.         //如果在Spring配置中设置了事务切入点  
  33.         if (this.pointcut != null) {  
  34.             //使用Spring默认的通知器封装事务切入点和事务***  
  35.             return new DefaultPointcutAdvisor(this.pointcut, this.transactionInterceptor);  
  36.         }  
  37.         //如果在Spring配置中没有设置事务切入点  
  38.         else {  
  39.             //使用TransactionAttributeSourceAdvisor封装默认的事务切入点  
  40.             return new TransactionAttributeSourceAdvisor(this.transactionInterceptor);  
  41.         }  
  42.     }  
  43. }   

通过上面对TransactionProxyFactoryBean的源码分析，我们看到，Spring的事务处理IoC容器TransactionProxyFactoryBean中主要通过依赖注入完成事务切入点和事务***的配置，最重要的功能是通过createMainInterceptor()方法为事务切入点和事务***创建AOP事务通知器。

TransactionProxyFactoryBean继承了AbstractSingletonProxyFactoryBean类，作为Spring事务管理IoC容器，其getObject()方法和IoC容器初始化完成之后回调的afterPropertiesSet()方法均是在其父类AbstractSingletonProxyFactoryBean中实现的，我们接下来分析AbstractSingletonProxyFactoryBean中事务处理相关源码的实现。

3.AbstractSingletonProxyFactoryBean创建配置事务：

AbstractSingletonProxyFactoryBean实现了FactoryBean和InitializingBean接口，Spring IoC容器最核心的getObject()和afterPropertiesSet()方法均是在该类中实现，AbstractSingletonProxyFactoryBean创建和配置事务相关的方法源码如下：

[java]  view plain copy
  1. //获取Spring事务***工厂(ProxyFactory)  
  2. public Object getObject() {  
  3.         if (this.proxy == null) {  
  4.             throw new FactoryBeanNotInitializedException();  
  5.         }  
  6.         return this.proxy;  
  7.     }  
  8. //InitializingBean接口的实现方法，IoC容器初始化完成之后的回调方法  
  9. public void afterPropertiesSet() {  
  10.         //事务的目标对象不能为空  
  11.         if (this.target == null) {  
  12.             throw new IllegalArgumentException("Property 'target' is required");  
  13.         }  
  14.         //事务目标对象必须是Bean引用，不能是Bean名称  
  15.         if (this.target instanceof String) {  
  16.             throw new IllegalArgumentException("'target' needs to be a bean reference, not a bean name as value");  
  17.         }  
  18.         //如果***类加载器为null，则使用默认的类加载器作用***类加载器  
  19.         if (this.proxyClassLoader == null) {  
  20.             this.proxyClassLoader = ClassUtils.getDefaultClassLoader();  
  21.         }  
  22. //创建***工厂，Spring事务管理容器TransactionProxyFactoryBean通过//ProxyFactory完成AOP的基本功能，ProxyFactory提供事务***对象，并将事务***设置为事务目标对象方法的***  
  23.         ProxyFactory proxyFactory = new ProxyFactory();  
  24.         //如果在事务***之前配置了额外的***  
  25.         if (this.preInterceptors != null) {  
  26.             //将这些事务之前的额外***添加到通知器中  
  27.             for (Object interceptor : this.preInterceptors) {  
  28.     proxyFactory.addAdvisor(this.advisorAdapterRegistry.wrap(interceptor));  
  29.             }  
  30.         }  
  31. //加入Spring AOP事务处理通知器，createMainInterceptor()方法  
  32. //由子类TransactionProxyFactoryBean提供实现    proxyFactory.addAdvisor(this.advisorAdapterRegistry.wrap(createMainInterceptor()));  
  33.         //如果在事务***之后配置了额外***  
  34.         if (this.postInterceptors != null) {  
  35.             //将这些事务之后的额外***添加到通知器中  
  36.             for (Object interceptor : this.postInterceptors) {  
  37.     proxyFactory.addAdvisor(this.advisorAdapterRegistry.wrap(interceptor));  
  38.             }  
  39.         }  
  40.         //从当前容器中复制事务AOP相关配置到ProxyFactory中  
  41.         proxyFactory.copyFrom(this);  
  42.         //创建AOP的目标源  
  43.         TargetSource targetSource = createTargetSource(this.target);  
  44.         //为ProxyFactory设置AOP目标源  
  45.         proxyFactory.setTargetSource(targetSource);  
  46.         //如果事务配置使用了***接口  
  47.         if (this.proxyInterfaces != null) {  
  48.             //为ProxyFactory设置***接口  
  49.             proxyFactory.setInterfaces(this.proxyInterfaces);  
  50.         }  
  51.         //如果事务***不是直接应用于目标类或者接口  
  52.         else if (!isProxyTargetClass()) {  
  53.             //将目标源的所有接口都设置为ProxyFactory的接口  
  54.             proxyFactory.setInterfaces(  
  55.     ClassUtils.getAllInterfacesForClass(targetSource.getTargetClass(), this.proxyClassLoader));  
  56.         }  
  57.         //ProxyFactory对象根据给定的类加载器创建事务***对象  
  58.         //具体的创建过程我们在Spring的AOP源码分析中已经分析过，Spring根据是否  
  59.         //实现接口而分别调用JDK动态***或者CGLIB方式创建AOP***对象  
  60.         this.proxy = proxyFactory.getProxy(this.proxyClassLoader);  
  61.     }  

通过上面对AbstractSingletonProxyFactoryBean创建和配置事务***对象相关源码分析我们看到，当Spring事务IoC容器初始化完成之后，事务容器回调afterPropertiesSet()方法创建事务AOP***对象。

4.TransactionAttributeSourceAdvisor读取Spring事务处理配置：

在2对TransactionProxyFactoryBean源码分析中，创建Spring事务的核心方法createMainInterceptor()中，根据给定的事务***创建事务属性源通知器TransactionAttributeSourceAdvisor，事务属性源通知器的核心源码如下：

[java]  view plain copy
  1. //事务***  
  2. private TransactionInterceptor transactionInterceptor;  
  3. //事务属性源切入点，一个实现事务属性源切入点接口的匿名内部类  
  4. private final TransactionAttributeSourcePointcut pointcut = new TransactionAttributeSourcePointcut() {  
  5.     //实现事务属性源切入点接口的获取事务属性源方法  
  6.     protected TransactionAttributeSource getTransactionAttributeSource() {  
  7.             //通过事务***获取事务的配置属性  
  8.             return (transactionInterceptor != null ? transactionInterceptor.getTransactionAttributeSource() : null);  
  9.         }  
  10.     };  
  11. //事务属性源通知器构造方法  
  12. public TransactionAttributeSourceAdvisor(TransactionInterceptor interceptor) {  
  13.         setTransactionInterceptor(interceptor);  
  14.     }  
  15. //设置事务***  
  16. public void setTransactionInterceptor(TransactionInterceptor interceptor) {  
  17.         this.transactionInterceptor = interceptor;  
  18.     }  

通过对事务属性源通知器TransactionAttributeSourceAdvisor的核心源码分析我们可以看到，事务属性源通知器的核心功能是为Spring的事务IoC容器设置事务属性源切入点和事务***。

5.事务切入点TransactionAttributeSourcePointcut匹配事务配置规则：

事务切入点TransactionAttributeSourcePointcut在事务属性源通知器中作为匿名内部类，用于根据事务的配置匹配符合规则的方法，事务切入点的核心源码如下：

[java]  view plain copy
  1. //匹配事务目标类的方法  
  2. public boolean matches(Method method, Class targetClass) {  
  3.         //获取事务属性源，getTransactionAttributeSource是一个抽象方法，在事  
  4. //务属性源通知器中实现  
  5.         TransactionAttributeSource tas = getTransactionAttributeSource();  
  6.         //返回指定类指定方法是否匹配事务属性  
  7.         return (tas == null || tas.getTransactionAttribute(method, targetClass) != null);  
  8.     }  

事务属性源TransactionAttributeSource在事务***TransactionInterceptor的父类事务切面支持TransactionAspectSupport中配置，源码如下：

[java]  view plain copy
  1. //配置事务属性源  
  2. public void setTransactionAttributes(Properties transactionAttributes) {  
  3.         //使用名称匹配的事务属性源  
  4.         NameMatchTransactionAttributeSource tas = new NameMatchTransactionAttributeSource();  
  5.         tas.setProperties(transactionAttributes);  
  6.         this.transactionAttributeSource = tas;  
  7.     }   

Spring默认使用名称匹配事务属性源NameMatchTransactionAttributeSource读取和匹配事务属性。

6.NameMatchTransactionAttributeSource读取和匹配事务属性：

名称匹配属性属性源从事务处理属性配置中读取事务的方法名和配置属性值，将得到的事务方法名和属性值保存到一个Map集合中，方法名作为key，事务属性值作为value。名称匹配事务属性源主要源码如下：

[java]  view plain copy
  1. public class NameMatchTransactionAttributeSource implements TransactionAttributeSource, Serializable {  
  2.     ……  
  3. //设置方法事务属性  
  4. public void setProperties(Properties transactionAttributes) {  
  5.         //创建事务属性解析器  
  6.         TransactionAttributeEditor tae = new TransactionAttributeEditor();  
  7.         //获取事务属性配置中所有属性名称  
  8.         Enumeration propNames = transactionAttributes.propertyNames();  
  9.         //遍历所有的事务属性  
  10.         while (propNames.hasMoreElements()) {  
  11.                 //获取事务属性配置的方法名  
  12.             String methodName = (String) propNames.nextElement();  
  13.             //获取方法配置的事务属性值  
  14.             String value = transactionAttributes.getProperty(methodName);  
  15.             //解析和格式化事务属性值  
  16.             tae.setAsText(value);  
  17.             //获取解析和格式化之后的事务属性  
  18.             TransactionAttribute attr = (TransactionAttribute) tae.getValue();  
  19.             //将方法名和其对应的事务属性添加到集合中  
  20.             addTransactionalMethod(methodName, attr);  
  21.         }  
  22.     }  
  23.     //将方法名称和该方法配置的事务属性添加到Map集合中  
  24.     public void addTransactionalMethod(String methodName, TransactionAttribute attr) {  
  25.         if (logger.isDebugEnabled()) {  
  26.             logger.debug("Adding transactional method [" + methodName + "] with attribute [" + attr + "]");  
  27.         }  
  28.         this.nameMap.put(methodName, attr);  
  29.     }  
  30.     //获取给定类给定方法中配置的事务属性  
  31.     public TransactionAttribute getTransactionAttribute(Method method, Class<?> targetClass) {  
  32.         //获取方法名  
  33.         String methodName = method.getName();  
  34.         //从方法名—>事务属性Map集合中获取给定方法名的事务属性  
  35.         TransactionAttribute attr = this.nameMap.get(methodName);  
  36.         //如果在方法名—>事务属性Map集合中没有给定方法名的事务属性  
  37.         if (attr == null) {  
  38.             String bestNameMatch = null;  
  39.             //判断给定方法名称是否在方法名—>事务属性Map集合的key中  
  40.             for (String mappedName : this.nameMap.keySet()) {  
  41.                 //如果给定的方法名在Map集合的key中匹配  
  42.                 if (isMatch(methodName, mappedName) &&  
  43.                         (bestNameMatch == null || bestNameMatch.length() <= mappedName.length())) {  
  44.                     //获取匹配方法的事务属性  
  45.                     attr = this.nameMap.get(mappedName);  
  46.                     bestNameMatch = mappedName;  
  47.                 }  
  48.             }  
  49.         }  
  50.         return attr;  
  51.     }  
  52.     //判断给定的方法名是否匹配，默认实现了"xxx*"，"*xxx"和"*xxx*"匹配检查  
  53.     protected boolean isMatch(String methodName, String mappedName) {  
  54.         return PatternMatchUtils.simpleMatch(mappedName, methodName);  
  55.     }  
  56. ……  
  57. }  

名称匹配事务属性源NameMatchTransactionAttributeSource主要在两个阶段发挥作用，在Spring事务IoC容器对事务配置读取解析时，事务容器调用名称匹配事务属性源的setProperties和addTransactionalMethod方法将方法名称和事务属性添加到Map集合中，当方法调用时，通过getTransactionAttribute方法获取方法所配置的事务属性。

7.事务***TransactionInterceptor的实现：

通过前面2到6的分析，管理Spring事务的IoC容器TransactionProxyFactoryBean已经完成了事务配置的读取，设置好了事务***和切入点。当应用调用被配置事务的方法时，首先通过getObject方法向Spring事务管理容器索取被被管理方法的事务属性，触发调用事务***的拦截方法进行事务处理。

在对Spring AOP源码分析中关于AOP***如何起作用时，我们知道Spring的AOP***通过invoke回调方法对切入点方法进行拦截处理，这个invoke方法是AOP联盟的方法***MethodInterceptor接口中定义的方法，用于对AOP***对象的方法进行包装处理。事务***TransactionInterceptor正是通过这个invoke拦截方法实现事务的拦截处理，源码如下：

[java]  view plain copy
  1. //事务***的拦截方法  
  2. public Object invoke(final MethodInvocation invocation) throws Throwable {  
  3.         //通过AOP获取事务的目标类  
  4.         Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);  
  5.         //通过事务属性源TransactionAttributeSource读取事务的属性配置，即调用上面名称匹配  
  6. //事务属性源NameMatchTransactionAttributeSource的方法  
  7.         final TransactionAttribute txAttr =  
  8.     getTransactionAttributeSource().getTransactionAttribute(invocation.getMethod(), targetClass);  
  9. //获取Spring事务管理IoC容器配置的事务处理器  
  10.         final PlatformTransactionManager tm = determineTransactionManager(txAttr);  
  11.         //获取目标类指定方法的事务连接点  
  12.         final String joinpointIdentification = methodIdentification(invocation.getMethod(), targetClass);  
  13. //区分不同类型的PlatformTransactionManager事务处理器，不同类型的事务处理器调用//方式不同。对CallbackPreferringPlatformTransactionManager，需要回调函数来//实现事务的创建和提交，对非CallbackPreferringPlatformTransactionManager来//说，则不需要使用回调函数来实现事务处理。  
  14.         //非CallbackPreferringPlatformTransactionManager类型的事务处理器  
  15.         if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {  
  16.             //创建事务，将当前事务状态和信息保存到TransactionInfo对象中  
  17.             TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);  
  18.             Object retVal = null;  
  19.             try {  
  20.                 //沿着***链调用处理，使得最后目标对象的方法得到调用  
  21.                 retVal = invocation.proceed();  
  22.             }  
  23.             catch (Throwable ex) {  
  24.                 //在调用***拦过程中出现异常，则根据事务配置进行提交或回滚处理  
  25.                 completeTransactionAfterThrowing(txInfo, ex);  
  26.                 throw ex;  
  27.             }  
  28.             //清除与当前线程绑定的事务信息  
  29.             finally {  
  30.                 cleanupTransactionInfo(txInfo);  
  31.             }  
  32.             //通过事务处理器来对事务进行提交  
  33.             commitTransactionAfterReturning(txInfo);  
  34.             return retVal;  
  35.         }  
  36.         //CallbackPreferringPlatformTransactionManager类型的事务处理器  
  37.         else {  
  38.             //通过回调函数对事务进行处理  
  39.             try {  
  40.                 //执行实现TransactionCallback接口的doInTransaction回调方法  
  41.                 Object result = ((CallbackPreferringPlatformTransactionManager) tm).execute(txAttr,  
  42.                         new TransactionCallback<Object>() {  
  43.                             //实现TransactionCallback接口匿名内部类的回调方法  
  44. public Object doInTransaction(TransactionStatus status) {  
  45.     //创建和准备事务  
  46.                                 TransactionInfo txInfo = prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);  
  47.                                 try {  
  48.                                     //沿着***拦调用  
  49.                                     return invocation.proceed();  
  50.                                 }  
  51.                                 //***链处理过程中产生异常  
  52.                                 catch (Throwable ex) {  
  53.                                     //如果事务对异常进行回滚处理  
  54.                                     if (txAttr.rollbackOn(ex)) {  
  55.                                         //如果异常时运行时异常，则事务回滚处理  
  56.                                        if (ex instanceof RuntimeException) {  
  57.                                             throw (RuntimeException) ex;  
  58.                                         }  
  59.                                         //如果不是运行时异常，则提交处理  
  60.                                         else {  
  61.                                             throw new ThrowableHolderException(ex);  
  62.                                         }  
  63.                                     }  
  64.                                     //如果事务对异常不进行回滚处理  
  65.                                     else {  
  66.                                         //提交处理  
  67.                                         return new ThrowableHolder(ex);  
  68.                                     }  
  69.                                 }  
  70.                                 //清除当前线程绑定的事务信息  
  71.                                 finally {  
  72.                                     cleanupTransactionInfo(txInfo);  
  73.                                 }  
  74.                             }  
  75.                         });  
  76.                 //对调用结果异常进行处理。  
  77. //如果是ThrowableHolder类型的异常，则转换为Throwable抛出  
  78.                 if (result instanceof ThrowableHolder) {  
  79.                     throw ((ThrowableHolder) result).getThrowable();  
  80.                 }  
  81.                 //如果不是ThrowableHolder类型的异常，则异常不做处理直接抛出  
  82.                 else {  
  83.                     return result;  
  84.                 }  
  85.             }  
  86.             catch (ThrowableHolderException ex) {  
  87.                 throw ex.getCause();  
  88.             }  
  89.         }  
  90.     }  

通过上面对事务***的拦截方法源码分析，我们可以看到Spring事务处理的基本工作流程：

(1).在调用方法时首先获取方法的事务属性配置，根据方法事务属性配置创建事务，获取Spring事务容器配置的事务处理器。

(2).调用具体的事务处理器对事务进行具体的处理。

(3).根据事务处理结果和事务处理过程中产生异常等进行提交或者回滚等处理。

事务拦截处理器TransactionInterceptor的invoke方法为Spring事务处理搭建一个通用的处理流程。