Spring源码深度解析之事务

Spring源码深度解析之事务

目录

一、JDBC方式下的事务使用示例

　　（1）创建数据表结构

　　（2）创建对应数据表的PO

　　（3）创建表和实体之间的映射

　　（4）创建数据操作接口

　　（5）创建数据操作接口实现类

　　（6）创建Spring配置文件

　　（7）测试

二、事务自定义标签

（一）注册InfrastructureAdvisorAutoProxyCreator

（二）获取对应class/method的增强器

　　（1）寻找候选增强器

　　（2）候选增强器中寻找到匹配项

三、事务增强器

（一）创建事务

　　（1）获取事务

　　（2）处理已经存在的事务

　　（3）准备事务信息

（二）回滚处理

　　（1）回滚条件

　　（2）回滚处理

　　（3）回滚后的信息清除

（三）事务提交

 

      Spring声明式事务让我们从复杂的事务处理中得到解脱，使我们再也不需要去处理获得连接、关闭连接、事务提交和回滚等操作。再也不需要在与事务相关的方法中处理大量的try…catch…finally代码。Spring中事务的使用虽然已经相对简单得多，但是，还是有很多的使用及配置规划，有兴趣的读者可以自己查阅相关资料进行深入的研究，这里只列举出最常用的使用方法。

      同样，我们还是以最简单的示例来进行直观的介绍。

一、JDBC方式下事务使用示例

（1）创建数据表结构

CREATE TABLE 'user'(
    'id' int(11) NOT NULL auto_increment,
    'name' varchar(255) default null,
    'age' int(11) default null,
    'sex' varchar(255) default null,
    PRIMARY KEY ('id')
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

（2）创建对应数据表的PO

public class User {
    private int id;
    private String name;
    private int age;
    private String sex;
    //省略set/get方法
}

（3）创建表和实体之间的映射

public class UserRowMapper implements RowMapper {
    @Override
    public Object mapRow(ResultSet set, int index) throws SQLException {
        User person = new User(set.getInt('id'), set.getString("name"), set.getInt("age"), set.getString("sex"));
        return person;
    }
}

（4）创建数据操作接口

@Transactional(propagation-Propagation.REQUIRED)
public interface UserService {
    public void save(User user) throws Exception;
}

（5）创建数据操作接口实现类

public class UserServiceImpl implements UserService {
    private JdbcTemplate jdbcTemplate;

    //设置数据源
    public void setDataSource(DataSource dataSource) {
        this.jdbcTemplate = new JdbcTemplate(dataSource);
    }

    public void save(User user) throws Exception {
        jdbcTemplate.update("insert into user(name, age, sex) value(?, ?, ?)",
                new Object[] {user.getName(), usr.getAge(), user.getSex()},
                new int[] {java.sql.Types.VARCHAR, java.sql.Type.INTEGER, java.sql.Types.VARCHAR});

        //事务测试，加上这句代码则数据不会保存到数据库中
        throw new RuntimeException("aa");
    }

}

（6）创建Spring配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://w3.org/2001/XMLSchema-instance"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                            http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
                            http://www.springframework.org/schema/context
                            http://www.springframework.org/schema/context/spring-context-2.5.xsd
                            http://www.springframework.org/schema/tx
                            http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

    <tx:annotation-driven transaction-manager="transactionManager"/>

    <bean id="transactionManager" class="org.springframe.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    //配置数据源
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="uri" value="jdbc:mysql://localhost:3306/lexueba"/>
        <property name="username" value="root"/>
        <property name="password" value="haojia0421xixi"/>
        <!--连接池启动时的初始值-->
        <property name="initialSize" value="1"/>
        <!--连接池的最大值-->
        <property name="maxActive" value="300"/>
        <!--最大空闲值，当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止-->
        <property name="maxIdle" value="2"/>
        <!--最小空闲值，当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请-->
        <property name="minIdle" value="1"/>
    </bean>

    <!--配置业务 bean:PersonServiceBean -->
    <bean id="userService" class="service.UserServiceImple">
        <!--向属性dataSource注入数据源-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

</beans>

（7）测试

public static void main(String[] args) throws Exception {
    ApplicationContext act = new ClassPathXmlApplicationContext("bean.xml");

    UserService userService = (UserService) act.getBean("userService");
    User user = new User();
    user.setName("张三CCC");
    user.setAge(20);
    user.setSex("男");
    //保存一条记录
    userService.save(user);
}

      上面测测试示例中，UserServiceImpl类对接口UserService中的save函数的实现最后加入了一句抛出异常的代码：throw new RuntimeException(“aa”)。当注释掉这段代码执行测试类，那么会看到数据被成功的保存到了数据库中，但是如果加入这段代码再次运行测试类，发现此处的操作并不会将数据保存到数据库中。

      注意：默认情况下，Spring中的事务处理只对RuntimeException方法进行回滚，所以，如果此处将RuntimeException替换成普通的Exception不会产生回滚效果。

 

二、事务自定义标签

　　对于Spring中事务功能的代码分析。我们首先从配置文件开始入手，在配置文件中有这样一个配置<tx:annotation-driven/>。可以说此处配置是事务的开关，如果没有此处的配置，那么Spring中将不存在事务的功能。那么我们就从这个配置开始分析。

　　根据之前的分析。我们因此可以判断，在自定义标签中的解析过程中一定是做了一些辅助性的操作，于是我们先从自定义的标签入手进行分析。

　　对于关键字annotation-driven，在TxNamespaceHandler类（package org.springframework.transaction.config）中的init()方法中进行了处理：

    public void init() {
        registerBeanDefinitionParser("advice", new TxAdviceBeanDefinitionParser());
        registerBeanDefinitionParser("annotation-driven", new AnnotationDrivenBeanDefinitionParser());
        registerBeanDefinitionParser("jta-transaction-manager", new JtaTransactionManagerBeanDefinitionParser());
    }

　　根据自定义标签的使用规则及上面的代码，可以知道，在遇到诸如<tx:annotation-driven为开头的配置后，Spring都会使用AnnotationDrivenBeanDefinitionParser类（package org.springframework.transaction.config）的parse()方法进行解析。

    public BeanDefinition parse(Element element, ParserContext parserContext) {
        registerTransactionalEventListenerFactory(parserContext);
        String mode = element.getAttribute("mode");
        if ("aspectj".equals(mode)) {
            // mode="aspectj"
            registerTransactionAspect(element, parserContext);
            if (ClassUtils.isPresent("javax.transaction.Transactional", getClass().getClassLoader())) {
                registerJtaTransactionAspect(element, parserContext);
            }
        }
        else {
            // mode="proxy"
            AopAutoProxyConfigurer.configureAutoProxyCreator(element, parserContext);
        }
        return null;
    }

　　在解析中存在对于mode属性的判断，根据代码，如果我们需要使用AspectJ的方式进行事务切入（Spring中的事务是以AOP为基础的），那么可以使用这样的配置：

<tx:annotation-driven transaction-manager="transactionManager"/ mode="aspectJ">

（一）注册InfrastructureAdvisorAutoProxyCreator

      我们以默认配置为例子进行分析，进入AopAutoProxyConfigurer类（AnnotationDrivenBeanDefinitionParser类的内部类）的configureAutoProxyCreator函数：

        public static void configureAutoProxyCreator(Element element, ParserContext parserContext) {
            AopNamespaceUtils.registerAutoProxyCreatorIfNecessary(parserContext, element);

            String txAdvisorBeanName = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME;
            if (!parserContext.getRegistry().containsBeanDefinition(txAdvisorBeanName)) {
                Object eleSource = parserContext.extractSource(element);

                // Create the TransactionAttributeSource definition.
                //创建TransactionAttributeSource的bean
                RootBeanDefinition sourceDef = new RootBeanDefinition(
                        "org.springframework.transaction.annotation.AnnotationTransactionAttributeSource");
                sourceDef.setSource(eleSource);
                sourceDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
                //注册bean，并使用Spring中的定义规则生成beanname
                String sourceName = parserContext.getReaderContext().registerWithGeneratedName(sourceDef);

                // Create the TransactionInterceptor definition.
                //创建TransactionInterceptor的bean
                RootBeanDefinition interceptorDef = new RootBeanDefinition(TransactionInterceptor.class);
                interceptorDef.setSource(eleSource);
                interceptorDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
                registerTransactionManager(element, interceptorDef);
                interceptorDef.getPropertyValues().add("transactionAttributeSource", new RuntimeBeanReference(sourceName));
                String interceptorName = parserContext.getReaderContext().registerWithGeneratedName(interceptorDef);

                // Create the TransactionAttributeSourceAdvisor definition.
                //创建TransactionAttributeSourceAdvisor的bean
                RootBeanDefinition advisorDef = new RootBeanDefinition(BeanFactoryTransactionAttributeSourceAdvisor.class);
                advisorDef.setSource(eleSource);
                advisorDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
                //将sourceName的bean注入advisorDef的transactionAttributeSource属性中
                advisorDef.getPropertyValues().add("transactionAttributeSource", new RuntimeBeanReference(sourceName));
                //将interceptorName的bean注入advisorDef的adviceBeanName属性中
                advisorDef.getPropertyValues().add("adviceBeanName", interceptorName);
                //如果配置了order属性，则加入到bean中
                if (element.hasAttribute("order")) {
                    advisorDef.getPropertyValues().add("order", element.getAttribute("order"));
                }
                parserContext.getRegistry().registerBeanDefinition(txAdvisorBeanName, advisorDef);

                //创建CompositeComponentDefinition
                CompositeComponentDefinition compositeDef = new CompositeComponentDefinition(element.getTagName(), eleSource);
                compositeDef.addNestedComponent(new BeanComponentDefinition(sourceDef, sourceName));
                compositeDef.addNestedComponent(new BeanComponentDefinition(interceptorDef, interceptorName));
                compositeDef.addNestedComponent(new BeanComponentDefinition(advisorDef, txAdvisorBeanName));
                parserContext.registerComponent(compositeDef);
            }
        }

　　上面的代码注册了代理类及三个bean，很多读者会直接略过，认为只是注册三个bean而已，确实，这里只注册量三个bean，但是这三个bean支撑了整个事务的功能，那么这三个bean是怎么组织起来的呢？

      首先，其中的两个bean被注册到了一个名为advisorDef的bean中，advisorDef使用BeanFactoryTransactionAttributeSourceAdvisor作为其class属性。也就是说BeanFactoryTransactionAttributeSourceAdvisor代表着当前bean，具体代码如下：

advisorDef.getPropertyValues().add("adviceBeanName", interceptorName);

      那么如此组装的目的是什么呢？先留下一个悬念，接着分析代码。上面configureAutoProxyCreator函数中的第一句貌似很简单但却是很重要的代码：

AopNamespaceUtils.registerAutoProxyCreatorIfNecessary(parserContext, element);

      进入这个函数，AopNamespaceUtils类（package org.springframework.aop.config）的registerAutoProxyCreatorIfNecessary函数：

    public static void registerAutoProxyCreatorIfNecessary(
            ParserContext parserContext, Element sourceElement) {

        BeanDefinition beanDefinition = AopConfigUtils.registerAutoProxyCreatorIfNecessary(
                parserContext.getRegistry(), parserContext.extractSource(sourceElement));
        useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);
        registerComponentIfNecessary(beanDefinition, parserContext);
    }

　　上面函数又调用了AopConfigUtils类（package org.springframework.aop.config）的registerAutoProxyCreatorIfNecessary函数：

    public static BeanDefinition registerAutoProxyCreatorIfNecessary(
            BeanDefinitionRegistry registry, @Nullable Object source) {

        return registerOrEscalateApcAsRequired(InfrastructureAdvisorAutoProxyCreator.class, registry, source);
    }

      对于解析来的额代码流程AOP中已经有所分析，上面两个函数主要的目的是注册InfrastructureAdvisorAutoProxyCreator类型（package org.springframework.aop.framework.autoproxy）的bean，那么注册这个类的目的是什么呢？

　　查看该类的层次结构，可以看到InfrastructureAdvisorAutoProxyCreator继承自AbstractAdvisorAutoProxyCreator继承自AbstractAutoProxyCreator继承自SmartInstantiationAwareBeanPostProcessor继承自InstantiationAwareBeanPostProcessor（含postProcessAfterInitialization方法），也就是说在Spring中，所有bean实例化时Spring都会保证调用其postProcessAfterInitialization方法。其实现是在父类AbstractAutoProxyCreator类中实现。

      以之前的示例为例，当实例化userService的bean时便会调用此方法，AbstractAutoProxyCreator类（packageorg.springframework.aop.framework.autoproxy）的postProcessAfterInitialization方法：

    public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
        if (bean != null) {
            //根据给定的bean的class和name构建出key，格式：beanClassName_beanName
            Object cacheKey = getCacheKey(bean.getClass(), beanName);
            if (this.earlyProxyReferences.remove(cacheKey) != bean) {
                //一个非常核心的方法：wrapIfNecessary(),如果它适合被代理，则需要封装指定的bean。
                return wrapIfNecessary(bean, beanName, cacheKey);
            }
        }
        return bean;
    }

　　这里实现的主要目的是对指定的bean进行封装，当然首先要确定是否需要封装，检测以及封装的的工作都委托给了wrapIfNecessary函数进行，AbstractAutoProxyCreator类的wrapIfNecessary方法：

    protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
        //如果已经处理过
        if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
            return bean;
        }
        //这个bean无需增强
        if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
            return bean;
        }
        //判断给定的bean是否是一个基础设施类，基础设施类不应代理，或者配置了指定bean不需要代理。
        //所谓InfrastructureClass就是指Advice/PointCut/Advisor等接口的实现类。
        if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return bean;
        }

        // 如果存在增强方法则创建代理
        //获取这个bean的advice
        Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
        //如果获取到了增强则需要针对增强创建代理
        if (specificInterceptors != DO_NOT_PROXY) {
            this.advisedBeans.put(cacheKey, Boolean.TRUE);
            //创建代理
            Object proxy = createProxy(
                    bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
            this.proxyTypes.put(cacheKey, proxy.getClass());
            return proxy;
        }

        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
    }

      WrapIfNecessary函数功能实现起来很复杂，但是逻辑上理解起来还是相对简单的，在wrapIfNecessary函数中主要的工作如下：

      ①找出指定bean对应的增强器。

      ②根据找出的增强器创建代理。

      听起来似乎简单的逻辑，Spring中又做了哪些复杂的工作呢？对于创建代理的部分，通过之前的分析大家已经很熟悉了，但是对于增强器的获取，Spring又是怎么做的呢？

（二）获取对应的class/method的增强器

      获取指定bean对应的增强器，其中包含两个关键字：增强器和对应。也就是说在getAdvicesAndAdvisorsForBean函数中，不但要找出增强器，而且还需要判断增强器是否满足要求。AbstractAutoProxyCreator类的wrapIfNecessary方法中调用了getAdvicesAndAdvisorsForBean，AbstractAutoProxyCreator类只对该方法进行定义，真正实现在其子类AbstractAdvisorAutoProxyCreator（package org.springframework.aop.framework.autoproxy）中：

    protected Object[] getAdvicesAndAdvisorsForBean(
            Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {

        List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
        if (advisors.isEmpty()) {
            return DO_NOT_PROXY;
        }
        return advisors.toArray();
    }

 　　上述函数调用了该类中的findEligibleAdvisors函数：

    protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
        List<Advisor> candidateAdvisors = findCandidateAdvisors();
        List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
        extendAdvisors(eligibleAdvisors);
        if (!eligibleAdvisors.isEmpty()) {
            eligibleAdvisors = sortAdvisors(eligibleAdvisors);
        }
        return eligibleAdvisors;
    }

      其实我们也渐渐地体会到Spring中代码的优秀，即使是一个很复杂的逻辑，在Spring中也会被拆分为若干个小的逻辑，然后在每个函数中实现，使得每个函数的逻辑简单到我们能快速的理解，而不会像有些人开发的那样，将一大堆的逻辑都罗列在一个函数中，给后期维护文员造成巨大的困扰。

      同样，通过上面的函数，Spring又将任务进行了拆分，分成了获取所有增强器与增强器是否匹配两个功能点。

（1）寻找候选增强器

      在findCandidateAdvisors函数中完成的就是获取增强器的功能，AbstractAdvisorAutoProxyCreator类的findCandidateAdvisors函数：

    protected List<Advisor> findCandidateAdvisors() {
        Assert.state(this.advisorRetrievalHelper != null, "No BeanFactoryAdvisorRetrievalHelper available");
        return this.advisorRetrievalHelper.findAdvisorBeans();
    }

　　上面函数调用了advisorRetrievalHelper类（package org.springframework.aop.framework.autoproxy）的findAdvisorBeans函数，进入函数：

    public List<Advisor> findAdvisorBeans() {
        //cachedAdvisorBeanNames是advisor名称的缓存
        String[] advisorNames = this.cachedAdvisorBeanNames;
        //如果cachedAdvisorBeanNames为空，则到容器中查找，并设置缓存，后续直接使用缓存即可
        if (advisorNames == null) {
            // Do not initialize FactoryBeans here: We need to leave all regular beans
            // uninitialized to let the auto-proxy creator apply to them!
            //从容器中查找Advisor类型的bean的名称
            advisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
                    this.beanFactory, Advisor.class, true, false);
            this.cachedAdvisorBeanNames = advisorNames;
        }
        if (advisorNames.length == 0) {
            return new ArrayList<>();
        }

        List<Advisor> advisors = new ArrayList<>();
        //遍历advisorNames
        for (String name : advisorNames) {
            if (isEligibleBean(name)) {
                //忽略郑州创建中的advisor bean
                if (this.beanFactory.isCurrentlyInCreation(name)) {
                    if (logger.isTraceEnabled()) {
                        logger.trace("Skipping currently created advisor '" + name + "'");
                    }
                }
                else {
                    try {
                        //调用getBean方法从容器中获取名称为name的bean，并将bean添加到advisors中
                        advisors.add(this.beanFactory.getBean(name, Advisor.class));
                    }
                    catch (BeanCreationException ex) {
                        Throwable rootCause = ex.getMostSpecificCause();
                        if (rootCause instanceof BeanCurrentlyInCreationException) {
                            BeanCreationException bce = (BeanCreationException) rootCause;
                            String bceBeanName = bce.getBeanName();
                            if (bceBeanName != null && this.beanFactory.isCurrentlyInCreation(bceBeanName)) {
                                if (logger.isTraceEnabled()) {
                                    logger.trace("Skipping advisor '" + name +
                                            "' with dependency on currently created bean: " + ex.getMessage());
                                }
                                // Ignore: indicates a reference back to the bean we're trying to advise.
                                // We want to find advisors other than the currently created bean itself.
                                continue;
                            }
                        }
                        throw ex;
                    }
                }
            }
        }
        return advisors;
    }

      对于上面的函数，你看懂其中的奥秘了吗？首先是通过BeanFactoryUtils类提供的工具方法获取所有对应的Advisor.class的类。

//从容器中查找Advisor类型的bean的名称
advisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
      this.beanFactory, Advisor.class, true, false);

      进入BeanFactoryUtils类（package org.springframework.beans.factory）的beanNamesForTypeIncludingAncestors函数：

    public static String[] beanNamesForTypeIncludingAncestors(
            ListableBeanFactory lbf, ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit) {

        Assert.notNull(lbf, "ListableBeanFactory must not be null");
        String[] result = lbf.getBeanNamesForType(type, includeNonSingletons, allowEagerInit);
        if (lbf instanceof HierarchicalBeanFactory) {
            HierarchicalBeanFactory hbf = (HierarchicalBeanFactory) lbf;
            if (hbf.getParentBeanFactory() instanceof ListableBeanFactory) {
                String[] parentResult = beanNamesForTypeIncludingAncestors(
                        (ListableBeanFactory) hbf.getParentBeanFactory(), type, includeNonSingletons, allowEagerInit);
                result = mergeNamesWithParent(result, parentResult, hbf);
            }
        }
        return result;
    }

      从上面代码可以看出，实际调用的是ListableBeanFactory类提供的getBeanNamesForType函数。

      而当我们知道增强器在容器中beanName时，获取增强器已经不是问题了，在BeanFactory中提供了这样的方法，可以帮助我们快速的定位对应的bean实例。

<T> T getBean(String name, Class<T> requiredType) throws BeansException;

　　或许你已经忘了之前留下的悬念，在我们讲解自定义标签时曾经注册了一个类型为BeanFactoryTransactionAttributeSourceAdvisor的bean，（package org.springframework.transaction.config 包中的AnnotationDrivenBeanDefinitionParser类的内部类AopAutoProxyConfigurer类中），而在此bean总我们又注入另外两个Bean，那么此时这个Bean就会被开始使用了。因为BeanFactoryTransactionAttributeSourceAdvisor同样也实现了Advisor接口，那么在获取所有增强器是自然也会将此bean提取出来并随着其他增强器一起在 后续的步骤中被织入代理。

（2）候选增强器中寻找到匹配项

　　当找出对应的增强后，接下来的任务就是看这些增强是否与对应的class匹配了，当然不只是class，class内部的方法如果匹配也可以通过验证，AbstractAdvisorAutoProxyCreator类（packageorg.springframework.aop.framework.autoproxy）的findAdvisorsThatCanApply函数：

    protected List<Advisor> findAdvisorsThatCanApply(
            List<Advisor> candidateAdvisors, Class<?> beanClass, String beanName) {

        ProxyCreationContext.setCurrentProxiedBeanName(beanName);
        try {
            return AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass);
        }
        finally {
            ProxyCreationContext.setCurrentProxiedBeanName(null);
        }
    }

　　其中又调用了AopUtils类（package org.springframework.aop.support）的findAdvisorsThatCanApply函数：

    public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz) {
        if (candidateAdvisors.isEmpty()) {
            return candidateAdvisors;
        }
        List<Advisor> eligibleAdvisors = new ArrayList<>();
        for (Advisor candidate : candidateAdvisors) {
            //刷选IntroductionAdvisor引介类型的通知器
            if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) {
                eligibleAdvisors.add(candidate);
            }
        }
        boolean hasIntroductions = !eligibleAdvisors.isEmpty();
        for (Advisor candidate : candidateAdvisors) {
            if (candidate instanceof IntroductionAdvisor) {
                //引介增强已经处理
                continue;
            }
            //刷选普通类型的通知器
            if (canApply(candidate, clazz, hasIntroductions)) {
                eligibleAdvisors.add(candidate);
            }
        }
        return eligibleAdvisors;
    }

　　上面函数调用了该类中的canApply函数：

    public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) {
        if (advisor instanceof IntroductionAdvisor) {
            /*
             * 从通知器中获取类型过滤器 ClassFilter，并调用 matchers 方法进行匹配。
             * ClassFilter 接口的实现类 AspectJExpressionPointcut 为例，该类的
             * 匹配工作由 AspectJ 表达式解析器负责，具体匹配细节这个就没法分析了，我
             * AspectJ 表达式的工作流程不是很熟
             */
            return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
        }
        else if (advisor instanceof PointcutAdvisor) {
            PointcutAdvisor pca = (PointcutAdvisor) advisor;
            // 对于普通类型的通知器，这里继续调用重载方法进行筛选
            return canApply(pca.getPointcut(), targetClass, hasIntroductions);
        }
        else {
            // It doesn't have a pointcut so we assume it applies.
            return true;
        }
    }

　　当前我们分析的是对于UserService是否适用于此增强方法，那么当前的advisor就是之前查找出来的类型为BeanFactoryTransactionAttributeSourceAdvisor的bean实例，而通过类的层次几个我们又知道：BeanFactoryTransactionAttributeSourceAdvisor间接实现了PointAdvisor（BeanFactoryTransactionAttributeSourceAdvisor继承自AbstractBeanFactoryPointcutAdvisor继承自AbstractPointcutAdvisor继承自PointcutAdvisor）。因此，在canApply函数中的第二个if判断时就会通过判断，会将BeanFactoryTransactionAttributeSourceAdvisor中的getPointcut()方法返回值作为参数继续调用canApply方法，而getPointcut ()方法返回的是TransactionAttributeSourcePointcut类型的实例。对于transactionAttributeSource这个属性大家还有印象吗？这是在解析自定义标签时注入进去的。BeanFactoryTransactionAttributeSourceAdvisor类中代码：

private final TransactionAttributeSourcePointcut pointcut = new TransactionAttributeSourcePointcut() {
    @Override 
    @Nullable 
    protected TransactionAttributeSource getTransactionAttributeSource() {
        return transactionAttributeSource;
    }
};

　　那么使用TransactionAttributeSourcePointcut类型的实例作为函数参数继续跟踪canApply，AopUtils类（package org.springframework.aop.support）的CanApply函数：

    public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) {
        Assert.notNull(pc, "Pointcut must not be null");
        //使用 ClassFilter 匹配 class
        if (!pc.getClassFilter().matches(targetClass)) {
            return false;
        }

        MethodMatcher methodMatcher = pc.getMethodMatcher();
        if (methodMatcher == MethodMatcher.TRUE) {
            // No need to iterate the methods if we're matching any method anyway...
            return true;
        }

        IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;
        if (methodMatcher instanceof IntroductionAwareMethodMatcher) {
            introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher;
        }


        /*
         * 查找当前类及其父类（以及父类的父类等等）所实现的接口，由于接口中的方法是 public，
         * 所以当前类可以继承其父类，和父类的父类中所有的接口方法
         */
        Set<Class<?>> classes = new LinkedHashSet<>();
        if (!Proxy.isProxyClass(targetClass)) {
            classes.add(ClassUtils.getUserClass(targetClass));
        }
        classes.addAll(ClassUtils.getAllInterfacesForClassAsSet(targetClass));

        for (Class<?> clazz : classes) {
            // 获取当前类的方法列表，包括从父类中继承的方法
            Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
            for (Method method : methods) {
                // 使用 methodMatcher 匹配方法，匹配成功即可立即返回
                if (introductionAwareMethodMatcher != null ?
                        introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions) :
                        methodMatcher.matches(method, targetClass)) {
                    return true;
                }
            }
        }

        return false;
    }

      通过上面函数大致可以理清大体脉络，首先获取对应类的所有接口并连同类本身一起遍历，遍历过程中又对类中的方法再次遍历，一旦匹配成功便认为这个类适用于当前的增强器。

      到这里我们不禁会有疑问，对于事务的配置不仅仅局限于在函数上配置，我们都知道，在类或接口上的配置可以延续到类中的每个函数。那么，如果针对每个函数进行检测，在类本身上配置的事务属性岂不是检测不到了吗？带着这个疑问，我们继续探求matcher方法。

      做匹配的时候methodMatcher.matches(method, targetClass)会使用TransactionAttributeSourcePointcut类（package org.springframework.transaction.interceptor）的matches方法。

    public boolean matches(Method method, Class<?> targetClass) {
        //自定义标签解析时注入
        TransactionAttributeSource tas = getTransactionAttributeSource();
        return (tas == null || tas.getTransactionAttribute(method, targetClass) != null);
    }

　　此时的tas表示AnnotationTransactionAttributeSource类型，而AnnotationTransactionAttributeSource类型的getTransactionAttribute方法如下（该方法在其父类AbstractFallbackTransactionAttributeSource中）。AbstractFallbackTransactionAttributeSource类（package org.springframework.transaction.interceptor）的getTransactionAttribute方法

    public TransactionAttribute getTransactionAttribute(Method method, @Nullable Class<?> targetClass) {
        if (method.getDeclaringClass() == Object.class) {
            return null;
        }

        // First, see if we have a cached value.
        Object cacheKey = getCacheKey(method, targetClass);
        TransactionAttribute cached = this.attributeCache.get(cacheKey);
        if (cached != null) {
            // Value will either be canonical value indicating there is no transaction attribute,
            // or an actual transaction attribute.
            if (cached == NULL_TRANSACTION_ATTRIBUTE) {
                return null;
            }
            else {
                return cached;
            }
        }
        else {
            // We need to work it out.
            TransactionAttribute txAttr = computeTransactionAttribute(method, targetClass);
            // Put it in the cache.
            if (txAttr == null) {
                this.attributeCache.put(cacheKey, NULL_TRANSACTION_ATTRIBUTE);
            }
            else {
                String methodIdentification = ClassUtils.getQualifiedMethodName(method, targetClass);
                if (txAttr instanceof DefaultTransactionAttribute) {
                    ((DefaultTransactionAttribute) txAttr).setDescriptor(methodIdentification);
                }
                if (logger.isTraceEnabled()) {
                    logger.trace("Adding transactional method '" + methodIdentification + "' with attribute: " + txAttr);
                }
                this.attributeCache.put(cacheKey, txAttr);
            }
            return txAttr;
        }
    }

      很遗憾，在getTransactionAttribute函数中并没有找到我们想要的代码，这里是指常规的一贯的套路。尝试从缓存加载，如果对应信息没有被缓存的话，工作又委托给了computeTransactionAttribute函数，在computeTransactionAttribute函数中我们看到了事务标签的提取过程。AbstractFallbackTransactionAttributeSource类的computeTransactionAttribute方法：

    protected TransactionAttribute computeTransactionAttribute(Method method, @Nullable Class<?> targetClass) {
        // Don't allow no-public methods as required.
        if (allowPublicMethodsOnly() && !Modifier.isPublic(method.getModifiers())) {
            return null;
        }

        // The method may be on an interface, but we need attributes from the target class.
        // If the target class is null, the method will be unchanged.
        //method代表接口中的方法，specificMethod代表类中的方法
        Method specificMethod = AopUtils.getMostSpecificMethod(method, targetClass);

        // First try is the method in the target class.
        //查看方法中是否存在事务声明
        TransactionAttribute txAttr = findTransactionAttribute(specificMethod);
        if (txAttr != null) {
            return txAttr;
        }

        // Second try is the transaction attribute on the target class.
        //查看方法所在的类是否存在事务声明
        txAttr = findTransactionAttribute(specificMethod.getDeclaringClass());
        if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
            return txAttr;
        }

        //如果存在接口，则到接口中去寻找
        if (specificMethod != method) {
            // Fallback is to look at the original method.
            //查找接口方法
            txAttr = findTransactionAttribute(method);
            if (txAttr != null) {
                return txAttr;
            }
            // Last fallback is the class of the original method.
            //到接口的类中去寻找
            txAttr = findTransactionAttribute(method.getDeclaringClass());
            if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
                return txAttr;
            }
        }

        return null;
    }

      对于事物属性的获取规则相信大家已经很清楚，如果方法中存在事务属性，则使用方法上的属性，否则使用方法所在的类上的属性，如果方法所在类的属性上还是没有搜寻到对应的事务属性，那么再搜寻接口中的方法，再没有的话，最后尝试搜寻接口的类上面的声明。对于函数computeTransactionAttribute中的逻辑与我们所认识的规则并无差别，但是上面函数中并没有真正的去做搜寻事务属性的逻辑，而是搭建了一个执行框架，将搜寻事务属性的任务委托给了findTransactionAttribute方法去执行。AnnotationTransactionAttributeSource类（package org.springframework.transaction.annotation）的findTransactionAttribute方法：

    protected TransactionAttribute findTransactionAttribute(Method method) {
        return determineTransactionAttribute(method);
    }

 　　上面函数调用了本类中的determineTransactionAttribute方法：

    protected TransactionAttribute determineTransactionAttribute(AnnotatedElement element) {
        for (TransactionAnnotationParser parser : this.annotationParsers) {
            TransactionAttribute attr = parser.parseTransactionAnnotation(element);
            if (attr != null) {
                return attr;
            }
        }
        return null;
    }

      this.annotationParsers是在当前类AnnotationTransactionAttributeSource初始化的时候初始化的，其中的值被加入了SpringTransactionAnnotationParser，也就是当进行属性获取的时候其实是使用SpringTransactionAnnotationParser类（package org.springframework.transaction.annotation）的parseTransactionAnnotation方法进行解析的：

    public TransactionAttribute parseTransactionAnnotation(AnnotatedElement element) {
        AnnotationAttributes attributes = AnnotatedElementUtils.findMergedAnnotationAttributes(
                element, Transactional.class, false, false);
        if (attributes != null) {
            return parseTransactionAnnotation(attributes);
        }
        else {
            return null;
        }
    }

　　至此，我们终于看到了想看到的获取注解标记的代码。首先会判断当前的类是否含有Transactional注解，这是事务属性的基础，当然如果有的话会继续调用SpringTransactionAnnotationParser类的parseTransactionAnnotation方法解析详细的属性：

    protected TransactionAttribute parseTransactionAnnotation(AnnotationAttributes attributes) {
        RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();

        //解析propagation
        Propagation propagation = attributes.getEnum("propagation");
        rbta.setPropagationBehavior(propagation.value());
        //解析isolation
        Isolation isolation = attributes.getEnum("isolation");
        rbta.setIsolationLevel(isolation.value());
        //解析timeout
        rbta.setTimeout(attributes.getNumber("timeout").intValue());
        //解析readOnly
        rbta.setReadOnly(attributes.getBoolean("readOnly"));
        //解析value
        rbta.setQualifier(attributes.getString("value"));

        //解析rollbackFor
        List<RollbackRuleAttribute> rollbackRules = new ArrayList<>();
        for (Class<?> rbRule : attributes.getClassArray("rollbackFor")) {
            rollbackRules.add(new RollbackRuleAttribute(rbRule));
        }
        //解析rollbackForClassName
        for (String rbRule : attributes.getStringArray("rollbackForClassName")) {
            rollbackRules.add(new RollbackRuleAttribute(rbRule));
        }
        //解析noRollbackFor
        for (Class<?> rbRule : attributes.getClassArray("noRollbackFor")) {
            rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
        }
        //noRollbackForClassName
        for (String rbRule : attributes.getStringArray("noRollbackForClassName")) {
            rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
        }
        rbta.setRollbackRules(rollbackRules);

        return rbta;
    }

      上面方法中实现了对对应类或者方法的事务属性解析，你会在这个类中看到任何你常用或者不常用的属性提取。

      至此，我们终于完成了事务标签的解析。我们是不是分析得太远了，似乎已经忘记了从哪里开始了。再回顾一下，我们现在的任务是找出某个增强器是否适合于对应的类，而是否匹配的关键则在于是否从指定的类或类中的方法中找到对应的事务属性，现在，我们以UserServiceImple为例，已经在它的接口UserService中找到了事务属性，所以，它是与事务增强器匹配的，也就是它会被事务功能修饰。

      至此，事务功能的初始化工作便结束了，当判断某个bean适用于事务增强时，也就是适用于增强器BeanFactoryTransactionAttributeSourceAdvisor。没错，还是这个类，所以说，在自定义标签解析时，注入的类成为了整个事务功能的基础。

      BeanFactoryTransactionAttributeSourceAdvisor作为Advisor的实现类，自然要遵从Advisor的处理方式，当代理被调用时会调用这个类的增强方法，也就是此bean的Advisor，又因为在解析事务定义标签时我们把TransactionInterceptor类型的bean注入到了BeanFactoryTransactionAttributeSourceAdvisor中，所以，在调用事务增强器增强的代理类时会首先执行TransactionInterceptor进行增强，同时，也就是TransactionInterceptor类的invoke方法中完成了整个事务的逻辑。

 

三、事务增强器

      TransactionInterceptor支撑着整个事务功能的架构，逻辑还是相对复杂的，那么现在我们切入正题来分析此拦截器是如何实现事务特性的。TransactionInterceptor类（package org.springframework.transaction.interceptor）继承自MethodInterceptor，所以调用该类是从其invoke方法开始的：

    public Object invoke(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);
    }

      其中又调用了其父类TransactionAspectSupport（package org.springframework.transaction.interceptor）的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.
        //获取对应事务属性
        TransactionAttributeSource tas = getTransactionAttributeSource();
        final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);
        //获取BeanFactory中的TransactionManager
        final TransactionManager tm = determineTransactionManager(txAttr);

        if (this.reactiveAdapterRegistry != null && tm instanceof ReactiveTransactionManager) {
            ReactiveTransactionSupport txSupport = this.transactionSupportCache.computeIfAbsent(method, key -> {
                if (KotlinDetector.isKotlinType(method.getDeclaringClass()) && KotlinDelegate.isSuspend(method)) {
                    throw new TransactionUsageException(
                            "Unsupported annotated transaction on suspending function detected: " + method +
                            ". Use TransactionalOperator.transactional extensions instead.");
                }
                ReactiveAdapter adapter = this.reactiveAdapterRegistry.getAdapter(method.getReturnType());
                if (adapter == null) {
                    throw new IllegalStateException("Cannot apply reactive transaction to non-reactive return type: " +
                            method.getReturnType());
                }
                return new ReactiveTransactionSupport(adapter);
            });
            return txSupport.invokeWithinTransaction(
                    method, targetClass, invocation, txAttr, (ReactiveTransactionManager) tm);
        }

        PlatformTransactionManager ptm = asPlatformTransactionManager(tm);
        //构造方法唯一标识（类.方法 如service.UserServiceImpl.save）
        final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);

        //声明式事务处理
        if (txAttr == null || !(ptm instanceof CallbackPreferringPlatformTransactionManager)) {
            // Standard transaction demarcation with getTransaction and commit/rollback calls.
            //创建TransactionInfo
            TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);

            Object retVal;
            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);
            }

            if (vavrPresent && VavrDelegate.isVavrTry(retVal)) {
                // Set rollback-only in case of Vavr failure matching our rollback rules...
                TransactionStatus status = txInfo.getTransactionStatus();
                if (status != null && txAttr != null) {
                    retVal = VavrDelegate.evaluateTryFailure(retVal, txAttr, status);
                }
            }

            //提交事务
            commitTransactionAfterReturning(txInfo);
            return retVal;
        }

        else {
            final ThrowableHolder throwableHolder = new ThrowableHolder();

            // It's a CallbackPreferringPlatformTransactionManager: pass a TransactionCallback in.
            //编程式事务处理
            try {
                Object result = ((CallbackPreferringPlatformTransactionManager) ptm).execute(txAttr, status -> {
                    TransactionInfo txInfo = prepareTransactionInfo(ptm, txAttr, joinpointIdentification, status);
                    try {
                        Object retVal = invocation.proceedWithInvocation();
                        if (vavrPresent && VavrDelegate.isVavrTry(retVal)) {
                            // Set rollback-only in case of Vavr failure matching our rollback rules...
                            retVal = VavrDelegate.evaluateTryFailure(retVal, txAttr, status);
                        }
                        return retVal;
                    }
                    catch (Throwable ex) {
                        if (txAttr.rollbackOn(ex)) {
                            // A RuntimeException: will lead to a rollback.
                            if (ex instanceof RuntimeException) {
                                throw (RuntimeException) ex;
                            }
                            else {
                                throw new ThrowableHolderException(ex);
                            }
                        }
                        else {
                            // A normal return value: will lead to a commit.
                            throwableHolder.throwable = ex;
                            return null;
                        }
                    }
                    finally {
                        cleanupTransactionInfo(txInfo);
                    }
                });

                // Check result state: It might indicate a Throwable to rethrow.
                if (throwableHolder.throwable != null) {
                    throw throwableHolder.throwable;
                }
                return result;
            }
            catch (ThrowableHolderException ex) {
                throw ex.getCause();
            }
            catch (TransactionSystemException ex2) {
                if (throwableHolder.throwable != null) {
                    logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
                    ex2.initApplicationException(throwableHolder.throwable);
                }
                throw ex2;
            }
            catch (Throwable ex2) {
                if (throwableHolder.throwable != null) {
                    logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
                }
                throw ex2;
            }
        }
    }

      从上面的函数中，我们尝试整理下事务处理的脉络，在Spring中支持两种事务处理的方式，分别是声明式事务处理和编程式事务处理，两者相对于开发人员来讲差别很大，但是对于Spring中的实现来讲，大同小异。在invoke中我们也可以看到这两种方式的实现。考虑到对事务的应用比声明式的事务处理使用起来方便，也相对流行些，我们就此种方式进行分析。对于声明式的事务处理主要有以下几个步骤。

      ① 获取事务的属性。

      对于事务处理来说，最基础或者最首要的工作便是获取事务的属性了。这是支撑整个事务功能的基石。如果没有事务属性，其他功能也就无从谈起，在分析事务准备阶段我们已经分析了事务属性提取的功能，大家应该有所了解。

      ② 加载配置中配置的TransactionManager。

      ③ 不同的事务处理方式使用不同的逻辑。

      对于声明式事务的处理与编程式事务的处理，第一点区别在于事务属性上，因为编程式的事务处理是不需要有事务属性的，第二点区别就是在TransactionManager上，CallbackPreferringPlatformTransactionManager实现了PlatformTransactionManager接口，暴露出一个方法用于执行事务处理中的回调。所以，这两种方式都可以用作事务处理方式的判断。

      ④ 在目标方法执行前获取事务并收集事务信息。

      事务信息与事务属性并不相同，也就是TransactionInfo与TransactionAttribute并不相同，TransactionInfo包含TransactionAttribute信息，但是，除了TransactionAttribute外还有其他事务信息，例如PlatformTransactionManager以及TransactionStatus相关信息。

      ⑤ 执行目标方法。

      ⑥ 一旦出现异常，尝试异常处理。

      ⑦ 提交事务前的事务信息清除。

      ⑧ 提交事务。

      上面的步骤分析旨在让大家对事务功能与步骤有个大致的了解，具体的功能还需要详细地分析。

（一）创建事务

      我们先分析事务创建的过程。TransactionAspectSupport类（package org.springframework.transaction.interceptor）的createTransactionIfNecessary方法：

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

        // If no name specified, apply method identification as transaction name.
        //如果没有名称指定则使用方法唯一标识，并使用DelegatingTransactionAttribute封装txAttr
        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) {
                //获取TransactionStatus
                status = tm.getTransaction(txAttr);
            }
            else {
                if (logger.isDebugEnabled()) {
                    logger.debug("Skipping transactional joinpoint [" + joinpointIdentification +
                            "] because no transaction manager has been configured");
                }
            }
        }
        //根据指定的属性与status准备一个TransactionInfo
        return prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
    }

      对于createTransactionIfNecessary函数主要做了这样几件事情。

      ① 使用DelegatingTransactionAttribute封装传入的TransactionAttribute实例。

      对于传入的TransactionAttribute类型的参数txAttr，当前的实际类型是RuleBasedTransactionAttribute，是由获取事务属性时生成的，主要用于数据承载，而这里之所以使用DelegatingTransactionAttribute进行封装，当时是提供了更多的功能。

      ② 获取事务

      事务处理当然是以事务为核心，那么获取事务就是最重要的事情。

      ③ 构建事务信息

      根据之前几个步骤获取的信息构建TransactionInfo并返回。

      我们分别对以上步骤进行详细的解析。

（1）获取事务

      Spring中使用getTransaction来处理事务的准备工作，包括事务获取以及信息的构建。getTransaction函数在实现PlatformTransactionManager接口的AbstractPlatformTransactionManager抽象类（package org.springframework.transaction.support）中给出了具体实现方法：

    public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition)
            throws TransactionException {

        // Use defaults if no transaction definition given.
        TransactionDefinition def = (definition != null ? definition : TransactionDefinition.withDefaults());

        Object transaction = doGetTransaction();
        boolean debugEnabled = logger.isDebugEnabled();

        //判断当前线程是否存在事务，判读依据为当前线程记录的连接不为空且连接中（connectionHolder）中的transactionActive属性不为空
        if (isExistingTransaction(transaction)) {
            // Existing transaction found -> check propagation behavior to find out how to behave.
            //当前线程已经存在事务
            return handleExistingTransaction(def, transaction, debugEnabled);
        }

        // Check definition settings for new transaction.
        //事务超时设置验证
        if (def.getTimeout() < TransactionDefinition.TIMEOUT_DEFAULT) {
            throw new InvalidTimeoutException("Invalid transaction timeout", def.getTimeout());
        }

        // No existing transaction found -> check propagation behavior to find out how to proceed.
        //如果当前线程不存在事务，但是PropagationBehavior却被声明为PROPAGATION_MANDATORY抛出异常
        if (def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
            throw new IllegalTransactionStateException(
                    "No existing transaction found for transaction marked with propagation 'mandatory'");
        }
        else if (def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||
                def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||
                def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
            //PROPAGATION_REQUIRED、PROPAGATION_REQUIRES_NEW、PROPAGATION_NESTED都需要新疆事务
            //空挂起
            SuspendedResourcesHolder suspendedResources = suspend(null);
            if (debugEnabled) {
                logger.debug("Creating new transaction with name [" + def.getName() + "]: " + def);
            }
            try {
                return startTransaction(def, transaction, debugEnabled, suspendedResources);
            }
            catch (RuntimeException | Error ex) {
                resume(null, suspendedResources);
                throw ex;
            }
        }
        else {
            // Create "empty" transaction: no actual transaction, but potentially synchronization.
            if (def.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT && logger.isWarnEnabled()) {
                logger.warn("Custom isolation level specified but no actual transaction initiated; " +
                        "isolation level will effectively be ignored: " + def);
            }
            boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
            return prepareTransactionStatus(def, null, true, newSynchronization, debugEnabled, null);
        }
    }

 　　上面函数调用了本类中的startTransaction函数：

    private TransactionStatus startTransaction(TransactionDefinition definition, Object transaction,
            boolean debugEnabled, @Nullable SuspendedResourcesHolder suspendedResources) {

        boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
        DefaultTransactionStatus status = newTransactionStatus(
                definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
        //构造transaction，包括设置ConnectionHolder、隔离级别、timeout。如果是新连接，绑定到当前线程
        doBegin(transaction, definition);
        //新同步事务的设置，针对当前线程的设置
        prepareSynchronization(status, definition);
        return status;
    }

      当然，在Spring中每个负责的功能实现，并不是一次完成的，而是会通过入口函数进行一个框架的搭建，初步构建完整的逻辑，而将实现细节分摊给不同的函数。那么，让我们看看事务的准备工作都包括哪些。

      ① 获取事务

      创建对应的事务实例，这里使用的是DataSourceTransactionManager（继承了AbstractPlatformTransactionManager抽象类）中的doGetTransaction方法，创建基于JDBC的事务实例。如果当前线程中存在关于dataSource的连接，那么直接使用。这里有一个对保存点的设置，是否开启运行保存点取决于是否设置了允许嵌入式事务。DataSourceTransactionManager类（package org.springframework.jdbc.datasource）的doGetTransaction方法：

    protected Object doGetTransaction() {
        DataSourceTransactionObject txObject = new DataSourceTransactionObject();
        txObject.setSavepointAllowed(isNestedTransactionAllowed());
        //如果当前线程已经记录数据库连接则使用原有连接
        ConnectionHolder conHolder =
                (ConnectionHolder) TransactionSynchronizationManager.getResource(obtainDataSource());
        //fasle表示非新创建连接。
        txObject.setConnectionHolder(conHolder, false);
        return txObject;
    }

      ② 如果当前线程存在事务，则转向嵌套事务的处理。

      ③ 事务超时设置验证。

      ④ 事务propagationBehavior属性的设置验证。

      ⑤ 构建DefaultTransactionStatus。

      ⑥ 完善transcation，包括设置ConnectionHolder、隔离级别、timeout，如果是新连接，则绑定到当前线程。

      对于一些隔离级别，timeout等功能的设置并不是由Spring来完成的，而是委托给底层的数据库连接去做的，而对于数据库连接的设置就是在doBegin函数中处理的。DataSourceTransactionManager类的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);
            txObject.setReadOnly(definition.isReadOnly());

            // 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).
            //更改自动提交设置，由Spring控制提交
            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);
            }

            // Bind the connection holder to the thread.
            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);
        }
    }

      可以说事务是从这个函数开始的，因为在这个函数中已经开始尝试了对数据库连接的获取，当然，在获取数据库连接的同时，一些必要的设置也是需要同步设置的。

      1) 尝试获取连接。

      当然并不是每次都会获取新的连接，如果当前线程中的ConnectionHolder已经存在，则没有必要再次获取，或者，对于事务同步表示设置为true的需要重新获取连接。

      2) 设置隔离级别以及只读标识。

      你是否有过这样的错觉？事务中的只读配置是Spring中做了一些处理呢？Spring中确实是针对只读操作做了一些处理，但是核心的实现是设置connection上的readOnly属性。通用，对于隔离级别的控制也是交由connection去控制的。

      3) 更改默认的提交设置。

      如果事务属性是自动提交的，那么需要改变这种设置，而将提交操作委托给Spring来处理。

      4) 设置标志位，标识当前连接已经被事务激活。

      5) 设置过期时间。

      6) 将connectionHolder绑定到当前线程。

      设置隔离级别的prepareConnectionForTransaction函数用于负责对底层数据库连接的设置。当然，只是包含只读标识和隔离级别的设置。由于强大的日志及异常处理，显得函数代码量比较大，但是单从业务角度去看，关键代码其实是不多的。DataSourceUtils类（package org.springframework.jdbc.datasource）的prepareConnectionForTransaction函数：

    public static Integer prepareConnectionForTransaction(Connection con, @Nullable TransactionDefinition definition)
            throws SQLException {

        Assert.notNull(con, "No Connection specified");

        // Set read-only flag.
        //设置数据连接的只读标识
        if (definition != null && definition.isReadOnly()) {
            try {
                if (logger.isDebugEnabled()) {
                    logger.debug("Setting JDBC Connection [" + con + "] read-only");
                }
                con.setReadOnly(true);
            }
            catch (SQLException | RuntimeException ex) {
                Throwable exToCheck = ex;
                while (exToCheck != null) {
                    if (exToCheck.getClass().getSimpleName().contains("Timeout")) {
                        // Assume it's a connection timeout that would otherwise get lost: e.g. from JDBC 4.0
                        throw ex;
                    }
                    exToCheck = exToCheck.getCause();
                }
                // "read-only not supported" SQLException -> ignore, it's just a hint anyway
                logger.debug("Could not set JDBC Connection read-only", ex);
            }
        }

        // Apply specific isolation level, if any.
        //设置数据库连接的隔离级别
        Integer previousIsolationLevel = null;
        if (definition != null && definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {
            if (logger.isDebugEnabled()) {
                logger.debug("Changing isolation level of JDBC Connection [" + con + "] to " +
                        definition.getIsolationLevel());
            }
            int currentIsolation = con.getTransactionIsolation();
            if (currentIsolation != definition.getIsolationLevel()) {
                previousIsolationLevel = currentIsolation;
                con.setTransactionIsolation(definition.getIsolationLevel());
            }
        }

        return previousIsolationLevel;
    }

      ⑦ 将事务信息记录在当前线程中。AbstractPlatformTransactionManager类（package org.springframework.transaction.support）中的prepareSynchronization函数：

    protected void prepareSynchronization(DefaultTransactionStatus status, TransactionDefinition definition) {
        if (status.isNewSynchronization()) {
            TransactionSynchronizationManager.setActualTransactionActive(status.hasTransaction());
            TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(
                    definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT ?
                            definition.getIsolationLevel() : null);
            TransactionSynchronizationManager.setCurrentTransactionReadOnly(definition.isReadOnly());
            TransactionSynchronizationManager.setCurrentTransactionName(definition.getName());
            TransactionSynchronizationManager.initSynchronization();
        }
    }

（2）处理已经存在的事务

　　AbstractPlatformTransactionManager类（package org.springframework.transaction.support）中的handleExistingTransaction函数：

    private TransactionStatus handleExistingTransaction(
            TransactionDefinition definition, Object transaction, boolean debugEnabled)
            throws TransactionException {

        if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NEVER) {
            throw new IllegalTransactionStateException(
                    "Existing transaction found for transaction marked with propagation 'never'");
        }

        if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NOT_SUPPORTED) {
            if (debugEnabled) {
                logger.debug("Suspending current transaction");
            }
            Object suspendedResources = suspend(transaction);
            boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
            return prepareTransactionStatus(
                    definition, null, false, newSynchronization, debugEnabled, suspendedResources);
        }

        if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW) {
            if (debugEnabled) {
                logger.debug("Suspending current transaction, creating new transaction with name [" +
                        definition.getName() + "]");
            }
            //新事物的建立
            SuspendedResourcesHolder suspendedResources = suspend(transaction);
            try {
                return startTransaction(definition, transaction, debugEnabled, suspendedResources);
            }
            catch (RuntimeException | Error beginEx) {
                resumeAfterBeginException(transaction, suspendedResources, beginEx);
                throw beginEx;
            }
        }

        //嵌入式事务的处理
        if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
            if (!isNestedTransactionAllowed()) {
                throw new NestedTransactionNotSupportedException(
                        "Transaction manager does not allow nested transactions by default - " +
                        "specify 'nestedTransactionAllowed' property with value 'true'");
            }
            if (debugEnabled) {
                logger.debug("Creating nested transaction with name [" + definition.getName() + "]");
            }
            if (useSavepointForNestedTransaction()) {
                // Create savepoint within existing Spring-managed transaction,
                // through the SavepointManager API implemented by TransactionStatus.
                // Usually uses JDBC 3.0 savepoints. Never activates Spring synchronization.
                //如果没有可以使用保存点的方式控制事务回滚，那么在嵌入式事务的建立初始建立保存点
                DefaultTransactionStatus status =
                        prepareTransactionStatus(definition, transaction, false, false, debugEnabled, null);
                status.createAndHoldSavepoint();
                return status;
            }
            else {
                // Nested transaction through nested begin and commit/rollback calls.
                // Usually only for JTA: Spring synchronization might get activated here
                // in case of a pre-existing JTA transaction.
                return startTransaction(definition, transaction, debugEnabled, null);
            }
        }

        // Assumably PROPAGATION_SUPPORTS or PROPAGATION_REQUIRED.
        if (debugEnabled) {
            logger.debug("Participating in existing transaction");
        }
        if (isValidateExistingTransaction()) {
            if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {
                Integer currentIsolationLevel = TransactionSynchronizationManager.getCurrentTransactionIsolationLevel();
                if (currentIsolationLevel == null || currentIsolationLevel != definition.getIsolationLevel()) {
                    Constants isoConstants = DefaultTransactionDefinition.constants;
                    throw new IllegalTransactionStateException("Participating transaction with definition [" +
                            definition + "] specifies isolation level which is incompatible with existing transaction: " +
                            (currentIsolationLevel != null ?
                                    isoConstants.toCode(currentIsolationLevel, DefaultTransactionDefinition.PREFIX_ISOLATION) :
                                    "(unknown)"));
                }
            }
            if (!definition.isReadOnly()) {
                if (TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {
                    throw new IllegalTransactionStateException("Participating transaction with definition [" +
                            definition + "] is not marked as read-only but existing transaction is");
                }
            }
        }
        boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
        return prepareTransactionStatus(definition, transaction, false, newSynchronization, debugEnabled, null);
    }

      对于已经存在事务的处理过程中，我们看到了很多熟悉的操作，但是，也有不同的地方，函数中对已经存在的事务处理考虑两种情况。

      ① PROPAGATION_REQUIRES_NEW表示当前方法必须在它自己的事务里运行，一个新的事务将被启动，而如果一个事务正在运行的话，则在这个方法运行期间被挂起。而Spring中国对于此种传播方式的处理与新事物建立最大的不同点在于使用suspend方法将原事务挂起。将信息挂起的目的当然是为了在当前事务执行完毕后再将原事务还原。

      ② PROPAGATION_NESTED表示如果当前正有一个事务在运行中，则该方法应该运行在一个嵌套的事务中，被嵌套的事务可以独立于封装事务进行提交或者回滚，如果封装事务不存在，行为就像PROPAGATION_REQUIRES_NEW。对于嵌入式事务的处理，Spring中主要考虑了两种方式的处理。

      1) Spring中允许嵌入事务的时候，则首选设置保存点的方式作为异常处理的回滚。

      2) 对于其他方式，比如JTA（Java Transaction API）无法使用保存点的方式，那么处理方式与PROPAGATION_REQUIRES_NEW相同，而一旦出现异常，则由Spring的事务异常处理机制去完成后续操作。

      对于挂起操作的主要目的是记录原有事务的状态，以便于后续操作对事务的恢复。AbstractPlatformTransactionManager类中的suspend函数：

    protected final SuspendedResourcesHolder suspend(@Nullable Object transaction) throws TransactionException {
        if (TransactionSynchronizationManager.isSynchronizationActive()) {
            List<TransactionSynchronization> suspendedSynchronizations = doSuspendSynchronization();
            try {
                Object suspendedResources = null;
                if (transaction != null) {
                    suspendedResources = doSuspend(transaction);
                }
                String name = TransactionSynchronizationManager.getCurrentTransactionName();
                TransactionSynchronizationManager.setCurrentTransactionName(null);
                boolean readOnly = TransactionSynchronizationManager.isCurrentTransactionReadOnly();
                TransactionSynchronizationManager.setCurrentTransactionReadOnly(false);
                Integer isolationLevel = TransactionSynchronizationManager.getCurrentTransactionIsolationLevel();
                TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(null);
                boolean wasActive = TransactionSynchronizationManager.isActualTransactionActive();
                TransactionSynchronizationManager.setActualTransactionActive(false);
                return new SuspendedResourcesHolder(
                        suspendedResources, suspendedSynchronizations, name, readOnly, isolationLevel, wasActive);
            }
            catch (RuntimeException | Error ex) {
                // doSuspend failed - original transaction is still active...
                doResumeSynchronization(suspendedSynchronizations);
                throw ex;
            }
        }
        else if (transaction != null) {
            // Transaction active but no synchronization active.
            Object suspendedResources = doSuspend(transaction);
            return new SuspendedResourcesHolder(suspendedResources);
        }
        else {
            // Neither transaction nor synchronization active.
            return null;
        }
    }

（3）准备事务信息

      当已经建立事务连接并完成了事务信息的提取后，我们需要将所有的事务信息统一记录在TransactionInfo。TransactionAspectSupport类（package org.springframework.transaction.interceptor）的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) {
            // We need a transaction for this method...
            if (logger.isTraceEnabled()) {
                logger.trace("Getting transaction for [" + txInfo.getJoinpointIdentification() + "]");
            }
            // The transaction manager will flag an error if an incompatible tx already exists.
            //记录事务的状态
            txInfo.newTransactionStatus(status);
        }
        else {
            // The TransactionInfo.hasTransaction() method will return false. We created it only
            // to preserve the integrity of the ThreadLocal stack maintained in this class.
            if (logger.isTraceEnabled()) {
                logger.trace("No need to create transaction for [" + joinpointIdentification +
                        "]: This method is not 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;
    }

 （二）回滚处理

      之前已经完成了目标方法运行前的事务准备工作，而这些准备工作最大的目的无非是对于程序没有安装我们期待的那样进行，也就是出现特定的错误。那么，当出现错误的时候，Spring是怎么对数据进行恢复的呢？TransactionAspectSupport类（package org.springframework.transaction.interceptor）的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);
            }
            //这里判断是否回滚默认的依据是抛出的异常是否是RuntimeException或者是Error的类型
            if (txInfo.transactionAttribute != null && txInfo.transactionAttribute.rollbackOn(ex)) {
                try {
                    //根据TransactionStatus信息进行回滚处理
                    txInfo.getTransactionManager().rollback(txInfo.getTransactionStatus());
                }
                catch (TransactionSystemException ex2) {
                    logger.error("Application exception overridden by rollback exception", ex);
                    ex2.initApplicationException(ex);
                    throw ex2;
                }
                catch (RuntimeException | Error ex2) {
                    logger.error("Application exception overridden by rollback exception", ex);
                    throw ex2;
                }
            }
            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 | Error ex2) {
                    logger.error("Application exception overridden by commit exception", ex);
                    throw ex2;
                }
            }
        }
    }

      在对目标方法的执行过程中，一旦出现Throwable就会被引导至此方法处理，但是并不代表所有的Throwable都会被回滚处理，比如我们最常用的Exception，默认是不会被处理的。默认情况下，即使出现异常，数据也会被正常提交，而这个关键的地方就是在txInfo.transactionAttribute.rollbackOn(ex)这个函数。

（1）回滚条件

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

　　看到了吗？默认情况下Spring中的事务异常机制只对RuntimeException和Error两种情况感兴趣，当然你可以通过扩展来改变，不过，我们最常用的还是使用事务提供的属性设置，利用注解方式的使用，例如：

@Transactional(propagation=Propagation.REQUIRED, rollbackFor=Exception.class)

（2）回滚处理

      当然，一旦符合回滚条件，那么Spring就会将程序引导至回滚处理函数中。AbstractPlatformTransactionManager类（package org.springframework.transaction.support）中的rollback函数：

    public final void rollback(TransactionStatus status) throws TransactionException {
        //如果事务已经完成，那么在此回滚会抛出异常
        if (status.isCompleted()) {
            throw new IllegalTransactionStateException(
                    "Transaction is already completed - do not call commit or rollback more than once per transaction");
        }

        DefaultTransactionStatus defStatus = (DefaultTransactionStatus) status;
        processRollback(defStatus, false);
    }

 　　上面函数又调用了本类中的processRollback函数：

    private void processRollback(DefaultTransactionStatus status, boolean unexpected) {
        try {
            boolean unexpectedRollback = unexpected;

            try {
                //激活所有TransactionSynchronizatioin中对应的方法
                triggerBeforeCompletion(status);

                if (status.hasSavepoint()) {
                    if (status.isDebug()) {
                        logger.debug("Rolling back transaction to savepoint");
                    }
                    //如果有保存点，也就是当前事务为单独的线程则会退到保存点
                    status.rollbackToHeldSavepoint();
                }
                else if (status.isNewTransaction()) {
                    if (status.isDebug()) {
                        logger.debug("Initiating transaction rollback");
                    }
                    //如果当前事务为独立的新事物，则直接回退
                    doRollback(status);
                }
                else {
                    // Participating in larger transaction
                    if (status.hasTransaction()) {
                        if (status.isLocalRollbackOnly() || isGlobalRollbackOnParticipationFailure()) {
                            if (status.isDebug()) {
                                logger.debug("Participating transaction failed - marking existing transaction as rollback-only");
                            }
                            //如果当前事务不是独立的事务，那么只能标记状态，等待事务链执行完毕后统一回滚
                            doSetRollbackOnly(status);
                        }
                        else {
                            if (status.isDebug()) {
                                logger.debug("Participating transaction failed - letting transaction originator decide on rollback");
                            }
                        }
                    }
                    else {
                        logger.debug("Should roll back transaction but cannot - no transaction available");
                    }
                    // Unexpected rollback only matters here if we're asked to fail early
                    if (!isFailEarlyOnGlobalRollbackOnly()) {
                        unexpectedRollback = false;
                    }
                }
            }
            catch (RuntimeException | Error ex) {
                triggerAfterCompletion(status, TransactionSynchronization.STATUS_UNKNOWN);
                throw ex;
            }

            //激活所有TransactionSynchronization中对应的方法
            triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK);

            // Raise UnexpectedRollbackException if we had a global rollback-only marker
            if (unexpectedRollback) {
                throw new UnexpectedRollbackException(
                        "Transaction rolled back because it has been marked as rollback-only");
            }
        }
        finally {
            //清空记录的资源并将挂起的资源恢复
            cleanupAfterCompletion(status);
        }
    }

      同样，对于在Spring中的复杂的逻辑处理过程，在入口函数一般都会给出个整体的处理脉络，而吧实现细节委托给其他函数去执行。我们尝试总结下Spring中对于回滚处理的大致脉络如下：

      ① 首先是自定义触发器的调用，包括在回滚前、完成回滚后的调用，当然完成回滚包括正常回滚与回滚过程中出现异常，自定义的触发器会根据这些信息作进一步处理，而对于触发器的注册，常见的是在回调过程中通过TransactionSynchronizationManager（package org.springframework.transaction.support）类中的静态方法registerSynchronization直接注册：

    public static void registerSynchronization(TransactionSynchronization synchronization)
            throws IllegalStateException {

        Assert.notNull(synchronization, "TransactionSynchronization must not be null");
        Set<TransactionSynchronization> synchs = synchronizations.get();
        if (synchs == null) {
            throw new IllegalStateException("Transaction synchronization is not active");
        }
        synchs.add(synchronization);
    }

     ② 除了触发监听函数外，就是真正的回滚逻辑处理了。

      当之前已经保存的事务信息中有保存点信息的时候，使用保存点信息进行回滚。常用语嵌入式事务。对于嵌入式的事务的处理，内嵌的事务异常并不会引起外部事务的回滚。

      根据保存点回滚的实现方式其实是根据底层的数据库连接进行的。AbstractTransactionStatus类（package org.springframework.transaction.support）的rollbackToHeldSavepoint函数：

    public void rollbackToHeldSavepoint() throws TransactionException {
        Object savepoint = getSavepoint();
        if (savepoint == null) {
            throw new TransactionUsageException(
                    "Cannot roll back to savepoint - no savepoint associated with current transaction");
        }
        getSavepointManager().rollbackToSavepoint(savepoint);
        getSavepointManager().releaseSavepoint(savepoint);
        setSavepoint(null);
    }

      1) 这里使用的是JDBC的方式连接数据库，那么getSavepointManager()函数返回的是JdbcTransactionObjectSupport，也就是说上面函数会调用JdbcTransactionObjectSupport类（package org.springframework.jdbc.datasource）中的rollbackToSavepoint方法：

    public void rollbackToSavepoint(Object savepoint) throws TransactionException {
        ConnectionHolder conHolder = getConnectionHolderForSavepoint();
        try {
            conHolder.getConnection().rollback((Savepoint) savepoint);
            conHolder.resetRollbackOnly();
        }
        catch (Throwable ex) {
            throw new TransactionSystemException("Could not roll back to JDBC savepoint", ex);
        }
    }

       2) 当之前已经保存的事务信息中的事务为新事物，那么直接回滚。常用语单独事务的处理。对于没有保存点的回滚，Spring同样是使用底层数据库连接提供的API来操作的。由于我们使用的是DataSourceTransactionManager（package org.springframework.jdbc.datasource），那么doRollback函数会使用此类中的实现：

    protected void doRollback(DefaultTransactionStatus status) {
        DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
        Connection con = txObject.getConnectionHolder().getConnection();
        if (status.isDebug()) {
            logger.debug("Rolling back JDBC transaction on Connection [" + con + "]");
        }
        try {
            con.rollback();
        }
        catch (SQLException ex) {
            throw new TransactionSystemException("Could not roll back JDBC transaction", ex);
        }
    }

     3) 当前事务信息中表明是存在事务的，又不属于以上两种情况，多数用于JTA，只做回滚标识，等到提交的时候统一不提交。

（3）回滚后的信息清除

      对于回滚逻辑执行结束后，无论回滚是否成功，都必须要做的事情就是事务结束后的收尾工作。AbstractPlatformTransactionManager类（package org.springframework.transaction.support）中的cleanupAfterCompletion函数：

    private void cleanupAfterCompletion(DefaultTransactionStatus status) {
        //设置完成状态
        status.setCompleted();
        if (status.isNewSynchronization()) {
            TransactionSynchronizationManager.clear();
        }
        if (status.isNewTransaction()) {
            doCleanupAfterCompletion(status.getTransaction());
        }
        if (status.getSuspendedResources() != null) {
            if (status.isDebug()) {
                logger.debug("Resuming suspended transaction after completion of inner transaction");
            }
            Object transaction = (status.hasTransaction() ? status.getTransaction() : null);
            //结束之前事务的挂起状态
            resume(transaction, (SuspendedResourcesHolder) status.getSuspendedResources());
        }
    }

      从函数中得知，事务处理的收尾工作包括如下内容。

      ① 设置状态时对事务信息作完成标识以避免重复调用。

      ② 如果当前事务是新的同步状态，需要将绑定到当前线程的事务信息清除。

      ③ 如果是新事务需要做些清除资源的工作。DataSourceTransactionManager类（package org.springframework.jdbc.datasource）的doRollback方法：

    protected void doRollback(DefaultTransactionStatus status) {
        DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
        Connection con = txObject.getConnectionHolder().getConnection();
        if (status.isDebug()) {
            logger.debug("Rolling back JDBC transaction on Connection [" + con + "]");
        }
        try {
            con.rollback();
        }
        catch (SQLException ex) {
            throw new TransactionSystemException("Could not roll back JDBC transaction", ex);
        }
    }

      ④ 如果在事务执行前有事务挂起，那么当前事务执行结束后需要将挂起的事务恢复。AbstractPlatformTransactionManager类（package org.springframework.transaction.support）中的resume函数：

    protected final void resume(@Nullable Object transaction, @Nullable SuspendedResourcesHolder resourcesHolder)
            throws TransactionException {

        if (resourcesHolder != null) {
            Object suspendedResources = resourcesHolder.suspendedResources;
            if (suspendedResources != null) {
                doResume(transaction, suspendedResources);
            }
            List<TransactionSynchronization> suspendedSynchronizations = resourcesHolder.suspendedSynchronizations;
            if (suspendedSynchronizations != null) {
                TransactionSynchronizationManager.setActualTransactionActive(resourcesHolder.wasActive);
                TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(resourcesHolder.isolationLevel);
                TransactionSynchronizationManager.setCurrentTransactionReadOnly(resourcesHolder.readOnly);
                TransactionSynchronizationManager.setCurrentTransactionName(resourcesHolder.name);
                doResumeSynchronization(suspendedSynchronizations);
            }
        }
    }

 （三）事务提交

      之前我们分析了Spring的事务异常处理机制，那么事务的执行并没有出现任何的异常，也就意味着事务可以走正常事务提交的流程了。TransactionAspectSupport类（package org.springframework.transaction.interceptor）的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());
        }
    }

      在真正的数据提交之前，还需要做个判断。在我们分析事务异常处理规则的时候，当某个事务既没有保存点又不是新事务，Spring对它的处理放肆只是设置一个回滚标识。这个回滚标识在这里就会派上用场。主要的应用场景如下。

      某个事务是另一个事务的嵌入事务，但是，这些事务又不在Spring的管理范围内，或者无法设置保存点，那么Spring会通过设置回滚标识的方式来禁止提交。首先当某个嵌入事务发送回滚的时候会设置回滚标识，而等到外部事务提交时，一旦判断出当前事务流被设置了回滚标识，则由外部事务来统一进行整体事务的回滚。

      所以，当事务没有被异常捕获的时候也并不意味着一定会执行提交的过程。AbstractPlatformTransactionManager类（package org.springframework.transaction.support）的commit函数：

    public final void commit(TransactionStatus status) throws TransactionException {
        if (status.isCompleted()) {
            throw new IllegalTransactionStateException(
                    "Transaction is already completed - do not call commit or rollback more than once per transaction");
        }

        DefaultTransactionStatus defStatus = (DefaultTransactionStatus) status;
        //如果在事务链中已经被标记回滚，那么不会尝试提交事务，直接回滚
        if (defStatus.isLocalRollbackOnly()) {
            if (defStatus.isDebug()) {
                logger.debug("Transactional code has requested rollback");
            }
            processRollback(defStatus, false);
            return;
        }

        if (!shouldCommitOnGlobalRollbackOnly() && defStatus.isGlobalRollbackOnly()) {
            if (defStatus.isDebug()) {
                logger.debug("Global transaction is marked as rollback-only but transactional code requested commit");
            }
            processRollback(defStatus, true);
            return;
        }

        //处理事务提交
        processCommit(defStatus);
    }

      而当事务执行一切都正常的时候，便可以真正地进入提交流程了。AbstractPlatformTransactionManager类的processCommit函数：

    private void processCommit(DefaultTransactionStatus status) throws TransactionException {
        try {
            boolean beforeCompletionInvoked = false;

            try {
                boolean unexpectedRollback = false;
                //预留
                prepareForCommit(status);
                //添加的TransactionSynchronization中对应方法的调用
                triggerBeforeCommit(status);
                //添加的TransactionSynchronization中对应方法的调用
                triggerBeforeCompletion(status);
                beforeCompletionInvoked = true;

                if (status.hasSavepoint()) {
                    if (status.isDebug()) {
                        logger.debug("Releasing transaction savepoint");
                    }
                    unexpectedRollback = status.isGlobalRollbackOnly();
                    //如果存在保存点则清除保存点信息
                    status.releaseHeldSavepoint();
                }
                else if (status.isNewTransaction()) {
                    if (status.isDebug()) {
                        logger.debug("Initiating transaction commit");
                    }
                    unexpectedRollback = status.isGlobalRollbackOnly();
                    //如果是独立的事务则直接提交
                    doCommit(status);
                }
                else if (isFailEarlyOnGlobalRollbackOnly()) {
                    unexpectedRollback = status.isGlobalRollbackOnly();
                }

                // Throw UnexpectedRollbackException if we have a global rollback-only
                // marker but still didn't get a corresponding exception from commit.
                if (unexpectedRollback) {
                    throw new UnexpectedRollbackException(
                            "Transaction silently rolled back because it has been marked as rollback-only");
                }
            }
            catch (UnexpectedRollbackException ex) {
                // can only be caused by doCommit
                triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK);
                throw ex;
            }
            catch (TransactionException ex) {
                // can only be caused by doCommit
                if (isRollbackOnCommitFailure()) {
                    doRollbackOnCommitException(status, ex);
                }
                else {
                    triggerAfterCompletion(status, TransactionSynchronization.STATUS_UNKNOWN);
                }
                throw ex;
            }
            catch (RuntimeException | Error ex) {
                if (!beforeCompletionInvoked) {
                    //添加的TransactionSynchronization中的对应方法的调用
                    triggerBeforeCompletion(status);
                }
                //提交过程中出现异常则回滚
                doRollbackOnCommitException(status, ex);
                throw ex;
            }

            // Trigger afterCommit callbacks, with an exception thrown there
            // propagated to callers but the transaction still considered as committed.
            try {
                //添加的TransactionSynchronization中对应方法的调用
                triggerAfterCommit(status);
            }
            finally {
                triggerAfterCompletion(status, TransactionSynchronization.STATUS_COMMITTED);
            }

        }
        finally {
            cleanupAfterCompletion(status);
        }
    }

      在提交过程中也不是直接提交的，而是考虑了诸多的方面，符合提交的条件如下：

      ① 当事务状态中有保存点信息的话便不会去提交事务。

      ② 当事务非新事务的时候也不会去执行提交事务操作。

      此条件主要考虑内嵌事务的情况，对于内嵌事务，在Spring中正常的处理方式是将内嵌事务开始之前设置保存点，一旦内嵌事务出现异常便根据保存点信息进行回滚，但是如果没有出现异常，内嵌事务并不会单独提交，而是根据事务流由最外层事务负责提交。所有如果当前存在保存点信息便不是最外层事务，不做保存操作。对于是否是新事务的判断也是基于此考虑。

      如果程序通过了事务的层层把关，最后顺利进入了提交流程，那么同样，Spring会将事务提交的操作引导到底层数据库连接的API，进行事务提交。DataSourceTransactionManager类（package org.springframework.jdbc.datasource）的doCommit方法：

    protected void doCommit(DefaultTransactionStatus status) {
        DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
        Connection con = txObject.getConnectionHolder().getConnection();
        if (status.isDebug()) {
            logger.debug("Committing JDBC transaction on Connection [" + con + "]");
        }
        try {
            con.commit();
        }
        catch (SQLException ex) {
            throw new TransactionSystemException("Could not commit JDBC transaction", ex);
        }
    }

 

　　本文摘自《Spring源码深度解析》事务，作者：郝佳。本文代码基于的Spring版本为5.2.4.BUILD-SNAPSHOT，和原书代码部分会略有不同。

拓展阅读：

　　Spring框架之beans源码完全解析
　　Spring框架之AOP源码完全解析
　　Spring框架之jdbc源码完全解析
　　Spring源码深度解析之数据库连接JDBC
　　Spring框架之jms源码完全解析
　　Spring框架之事务源码完全解析
　　Spring源码深度解析之事务
　　Spring源码深度解析之Spring MVC
　　Spring框架之websocket源码完全解析
　　WebSocket协议中文版
　　Spring框架之spring-web web源码完全解析
　　Spring框架之spring-web http源码完全解析
　　Spring框架之spring-webmvc源码完全解析