Spring系列（六）：Spring事务源码解析

一、事务概述

　　1.1 什么是事务

　　事务是一组原子性的SQL查询，或者说是一个独立的工作单元。要么全部执行，要么全部不执行。

　　1.2 事务的特性(ACID)

　　①原子性（atomicity）

 　　一个事务必须被视为一个不可分割的最小工作单元，整个事务中的所有操作要么全部提交成功，要么全部回滚，对于一个事务来说，不可能只执行其中的一部分操作

　　②一致性（consistency）

　　数据库总是从一个一致性的状态转换到另外一个一致性的状态。

　　③隔离性（isolation）

　　一个事务所做的修改在最终提交以前，对其他事务是不可见的。也就是说多个并发事务之间要相互隔离。

　　④持久性（durability）

　　一旦事务提交，则其所做的修改就会永久的保存在数据库中，接下来即使数据库系统崩溃了，修改的数据也不会丢失

　　1.3 事务的隔离级别

　　①读未提交（READ UNCOMMITTED）

 　　事务中的修改，即使没有提交，对其他事务也是可见的，也就是说事务可以读取到未提交的数据，这也被称为脏读。

　　②读已提交（READ COMMITTED）

　　一个事务从开始到提交之前，所做的任何修改对其他事务都是不可见的，这个级别有时候也叫不可重复读，因为两次执行同样的查询，可能会得到不一样的结果。

　　③可重复读（REPEATABLE READ）

　　该隔离级别保证了在同一个事务中多次读取同样的记录的结果是一致的，但是无法解决另外一个幻读的问题，所谓的幻读就是指当某个事务在读取某个范围内的记录是，另外一个事务又在该范围内插入了新的记录，当之前的事务再次读取该范围的记录时就会产生幻行。

　　④可串行化（SERIALIZABLE）

　　SERIALIZABLE是最高的隔离级别，通过强制事务的串行执行，避免了前面说的幻读问题，简单来说，SERIALIZABLE会在读取的每一行数据上加上锁。

二、Spring事务关键接口

　　1 PlatformTransactionManager 事务管理器

public interface PlatformTransactionManager {

    /**
     * 获取事务
     */
    TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException;

    /**
     * 提交
     */
    void commit(TransactionStatus status) throws TransactionException;

    /**
     * 回滚
     */
    void rollback(TransactionStatus status) throws TransactionException;

}

　　2 TransactionDefinition 事务定义信息

public interface TransactionDefinition {

    /**
     * Support a current transaction; create a new one if none exists. 支持当前事物，若当前没有事物就创建一个事物
     */
    int PROPAGATION_REQUIRED = 0;

    /**
     * Support a current transaction; execute non-transactionally if none exists. 如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式运行
     */
    int PROPAGATION_SUPPORTS = 1;

    /**
     * Support a current transaction; throw an exception if no current transaction exists. 如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常
     */
    int PROPAGATION_MANDATORY = 2;

    /**
     * Create a new transaction, suspending the current transaction if one exists.创建一个新的事务，如果当前存在事务，则把当前事务挂起
     */
    int PROPAGATION_REQUIRES_NEW = 3;

    /**
     * Do not support a current transaction; rather always execute non-transactionally.以非事务方式运行，如果当前存在事务，则把当前事务挂起
     */
    int PROPAGATION_NOT_SUPPORTED = 4;

    /**
     * Do not support a current transaction; throw an exception if a current transaction exists. 以非事务方式运行，如果当前存在事务，则抛出异常
     */
    int PROPAGATION_NEVER = 5;

    /**
     * Execute within a nested transaction if a current transaction exists.如果外层存在事务，就以嵌套事务运行，被嵌套的事务可以独立于外层事务进行提交或者回滚(保存点)，
如果外层不存在事务,行为跟PROPAGATION_REQUIRES_NEW
     */
    int PROPAGATION_NESTED = 6;


    /**
     * Use the default isolation level of the underlying datastore. 使用数据库默认的隔离级别
　　　*/
    int ISOLATION_DEFAULT = -1;

    /**
     * 读未提交
　　　*/
    int ISOLATION_READ_UNCOMMITTED = Connection.TRANSACTION_READ_UNCOMMITTED;

    /**
     * 读已提交
　　  */
    int ISOLATION_READ_COMMITTED = Connection.TRANSACTION_READ_COMMITTED;

    /**
     * 可重复读*/
    int ISOLATION_REPEATABLE_READ = Connection.TRANSACTION_REPEATABLE_READ;

    /**
     * 可串行化
　　　*/
    int ISOLATION_SERIALIZABLE = Connection.TRANSACTION_SERIALIZABLE;


    /**
     * 使用默认的超时时间
     */
    int TIMEOUT_DEFAULT = -1;


    /**
     * 获取事物的传播行为
     */
    int getPropagationBehavior();

    /**
     * 获取事物的隔离级别
　　　*/
    int getIsolationLevel();

    /**
     * 获取事物的超时时间
　　  */
    int getTimeout();

    /**
     * 是否为只读事物
     */
    boolean isReadOnly();

    /**
     * 获取当前事物的名称
　　　*/
    String getName();

}

　　3 TransactionStatus 事务运行状态

public interface TransactionStatus extends SavepointManager, Flushable {

    /**
     * 是否为新事务
     */
    boolean isNewTransaction();

    /**
     * 是否有保存点*/
    boolean hasSavepoint();

    /**
     * 设置为只回滚*/
    void setRollbackOnly();

    /**
     * 是否为只回滚
     */
    boolean isRollbackOnly();

    /**
     * 讲会话刷新到数据库中
     */
    @Override
    void flush();

    /**
     * 当前事务是否已经完成*/
    boolean isCompleted();

}

三、Spring事务启动过程

　　1 @EnableTransactionManagement

　　1.1 在主配置类中添加@EnableTransactionManagement注解，开启Spring事务的支持，配置如下：

@EnableTransactionManagement
@ComponentScan(basePackages = {"com.toby"})
public class TransactionConfig {
    @Bean
    public DataSource dataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUsername("root");
        dataSource.setPassword("123qwe");
        dataSource.setUrl("jdbc:mysql://localhost:3306/demo_db?useUnicode=true&characterEncoding=utf-8&useSSL=false");
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        return dataSource;
    }

    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }

    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
}

　　1.2 @EnableTransactionManagement 到底做了什么？

　　源码解析跟Spring系列（五）：Spring AOP源码解析中的@EnableAspectJAutoProxy注解一样，可以参考下。主要给Spring容器加入如下组件：

 　　2 InfrastructureAdvisorAutoProxyCreator（重点）

　　2.1 首先看下类继承图

 　　2.2 实现了InstantiationAwareBeanPostProcessor接口

　　该接口有2个方法postProcessBeforeInstantiation和postProcessAfterInstantiation，其中实例化之前会执行postProcess BeforeInstantiation方法：

public Object postProcessBeforeInstantiation(Class beanClass, String beanName) throws BeansException {
        //构建我们的缓存key
        Object cacheKey = getCacheKey(beanClass, beanName);

        if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
            //如果被解析过直接返回
            if (this.advisedBeans.containsKey(cacheKey)) {
                return null;
            }
            /**
             * 判断是不是基础的bean
             * 判断是不是应该跳过 (此处Spring Aop解析直接解析出我们的切面信息(并且把我们的切面信息进行缓存)，
　　　　　　　　* 而事务在这里是不会解析的，为什么？原因事务的话已经把事务拦截器通过@Bean，而Aop的需要寻找)
             */
            if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
                this.advisedBeans.put(cacheKey, Boolean.FALSE);
                return null;
            }
        }

        TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
        if (targetSource != null) {
            if (StringUtils.hasLength(beanName)) {
                this.targetSourcedBeans.add(beanName);
            }
            Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
            Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
            this.proxyTypes.put(cacheKey, proxy.getClass());
            return proxy;
        }

        return null;
    }　　

　　2.3 实现了BeanPostProcessor接口

 　　该接口有2个方法postProcessBeforeInitialization和postProcessAfterInitialization，其中组件初始化之后会执行postProcessAfterInitialization（该方法创建Aop和事务的代理对象）方法：

/**
     * 在该后置方法中 我们的事务和aop的代理对象都是在这生成的
     * @param bean bean实例
     * @param beanName bean的名称
     * @return
     * @throws BeansException
     */
    @Override
    public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) throws BeansException {
        if (bean != null) {
            //获取缓存key
            Object cacheKey = getCacheKey(bean.getClass(), beanName);
            if (this.earlyProxyReferences.remove(cacheKey) != bean) {
                //如果有必要就代理
                return wrapIfNecessary(bean, beanName, cacheKey);
            }
        }
        return bean;
    }

　　进去wrapIfNecessary(bean, beanName, cacheKey)方法：

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
        //已经被处理过
        if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
            return bean;
        }
        //不需要增强的
        if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
            return bean;
        }
        //是不是基础的bean 是不是需要跳过的
        if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return bean;
        }

        //如果有匹配的通知,就创建代理对象
        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;
    }

　　进入getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null)方法：

protected Object[] getAdvicesAndAdvisorsForBean(
            Class beanClass, String beanName, @Nullable TargetSource targetSource) {
        /**
         * 找合适的增强器对象
         */
        List advisors = findEligibleAdvisors(beanClass, beanName);
        //若合适的通知器为空
        if (advisors.isEmpty()) {
            return DO_NOT_PROXY;
        }
        return advisors.toArray();
    }

　　进入findEligibleAdvisors(beanClass, beanName)方法：

protected List findEligibleAdvisors(Class beanClass, String beanName) {
        //找到Spring IoC容器中所有的候选通知 包括Aop的和事务的
        List candidateAdvisors = findCandidateAdvisors();
        //判断找到的通知能不能作用到当前的类上
        List eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
        extendAdvisors(eligibleAdvisors);
        //对我们的advisor进行排序
        if (!eligibleAdvisors.isEmpty()) {
            eligibleAdvisors = sortAdvisors(eligibleAdvisors);
        }
        return eligibleAdvisors;
    }

　　① 进入findCandidateAdvisors()方法，通过增强器检索器检索增强器：

 　　进入findAdvisorBeans()方法：

public List findAdvisorBeans() {

        String[] advisorNames = this.cachedAdvisorBeanNames;
        if (advisorNames == null) {
            /**
             * 去容器中获取到实现了Advisor接口的实现类 我们的事务注解@EnableTransactionManagement导入了一个叫ProxyTransactionManagementConfiguration配置类
             * 而在这个配置类中配置了：
             * @Bean(name = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME)
             * @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
             * public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor();
             * 然后把他的名字获取出来保存到 本类的属性变量cachedAdvisorBeanNames中
             */
            advisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
                    this.beanFactory, Advisor.class, true, false);
            this.cachedAdvisorBeanNames = advisorNames;
        }
        //若在容器中没有找到，直接返回一个空的集合
        if (advisorNames.length == 0) {
            return new ArrayList<>();
        }

        List advisors = new ArrayList<>();
        //容器中找到了我们事务配置的BeanFactoryTransactionAttributeSourceAdvisor
        for (String name : advisorNames) {
            //判断他是不是一个合适的
            if (isEligibleBean(name)) {
                //BeanFactoryTransactionAttributeSourceAdvisor是不是正在创建的Bean
                if (this.beanFactory.isCurrentlyInCreation(name)) {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Skipping currently created advisor '" + name + "'");
                    }
                }
                //不是的话
                else {
                    try {
                        //显示的调用getBean方法方法创建我们的BeanFactoryTransactionAttributeSourceAdvisor返回去
                        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.isDebugEnabled()) {
                                    logger.debug("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;
    }

　　进入到isEligibleBean(name)方法：

 　　进入isEligibleAdvisorBean(beanName)方法：

protected boolean isEligibleAdvisorBean(String beanName) {
        /**
         * 容器中包含了这个Bean定义，并且Bean定义的角色为BeanDefinition.ROLE_INFRASTRUCTURE
         */
        return (this.beanFactory != null && this.beanFactory.containsBeanDefinition(beanName) &&
                this.beanFactory.getBeanDefinition(beanName).getRole() == BeanDefinition.ROLE_INFRASTRUCTURE);
    }

　　如果是合适的就保存在advisors中并返回；至此findCandidateAdvisors()执行完毕！！！

　　② 找到的增强器是否能作用在当前的类上，findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName)方法：

 　　进入到AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass)方法：

public static List findAdvisorsThatCanApply(List candidateAdvisors, Class clazz) {
        //若候选的增强器集合为空直接返回
        if (candidateAdvisors.isEmpty()) {
            return candidateAdvisors;
        }
        //定义一个合适的增强器集合对象
        List 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) {
            //判断我们的增强器对象是不是实现了IntroductionAdvisor (很明显我们事务的没有实现 所以不会走下面的逻辑)
            if (candidate instanceof IntroductionAdvisor) {
                //在上面已经处理过 ，不需要处理
                continue;
            }
            /**
             * 真正的判断增强器是否合适当前类
             */
            if (canApply(candidate, clazz, hasIntroductions)) {
                eligibleAdvisors.add(candidate);
            }
        }
        return eligibleAdvisors;
    }

　　真正的判断增强器是否合适当前类，canApply(candidate, clazz, hasIntroductions)方法：

public static boolean canApply(Advisor advisor, Class targetClass, boolean hasIntroductions) {
        //判断我们的增强器 IntroductionAdvisor
        if (advisor instanceof IntroductionAdvisor) {
            return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
        }
        //判断我们事务的增强器BeanFactoryTransactionAttributeSourceAdvisor是否实现了PointcutAdvisor
        else if (advisor instanceof PointcutAdvisor) {
            //转为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;
        }
    }

　　找到真正能用的增强器，canApply(pca.getPointcut(), targetClass, hasIntroductions)方法：

public static boolean canApply(Pointcut pc, Class targetClass, boolean hasIntroductions) {
        Assert.notNull(pc, "Pointcut must not be null");
        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 introductionAwareMethodMatcher = null;
        if (methodMatcher instanceof IntroductionAwareMethodMatcher) {
            introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher;
        }

        //创建一个集合用于保存targetClass的class对象
        Set> classes = new LinkedHashSet<>();
        //判断当前class是不是代理的class对象
        if (!Proxy.isProxyClass(targetClass)) {
            //加入到集合中去
            classes.add(ClassUtils.getUserClass(targetClass));
        }
        //获取到targetClass所实现的接口的class对象，然后加入到集合中
        classes.addAll(ClassUtils.getAllInterfacesForClassAsSet(targetClass));

        //循环所有的class对象
        for (Class clazz : classes) {
            //通过class获取到所有的方法
            Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
            //循环我们的方法
            for (Method method : methods) {
                //通过methodMatcher.matches来匹配我们的方法
                if (introductionAwareMethodMatcher != null ?
                        introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions) :
                        //通过方法匹配器进行匹配
                        methodMatcher.matches(method, targetClass)) {
                    return true;
                }
            }
        }
        return false;
    }

　　进入methodMatcher.matches(method, targetClass)方法：

public boolean matches(Method method, @Nullable Class targetClass) {
        if (targetClass != null && TransactionalProxy.class.isAssignableFrom(targetClass)) {
            return false;
        }
        /**
         * 获取我们@EnableTransactionManagement注解为我们容器中导入的ProxyTransactionManagementConfiguration
         * 配置类中的TransactionAttributeSource对象
         */
        TransactionAttributeSource tas = getTransactionAttributeSource();
        //若事务属性原为null或者 解析出来的事务注解属性不为空    表示方法匹配
        return (tas == null || tas.getTransactionAttribute(method, targetClass) != null);
    }

　　进入到获取事务注解属性tas.getTransactionAttribute(method, targetClass)方法：

public TransactionAttribute getTransactionAttribute(Method method, @Nullable Class targetClass) {
        //判断method所在的class 是不是Object类型
        if (method.getDeclaringClass() == Object.class) {
            return null;
        }

        //构建我们的缓存key
        Object cacheKey = getCacheKey(method, targetClass);
        //先去我们的缓存中获取
        TransactionAttribute cached = this.attributeCache.get(cacheKey);
        //缓存中不为空
        if (cached != null) {
            //判断缓存中的对象是不是空事务属性的对象
            if (cached == NULL_TRANSACTION_ATTRIBUTE) {
                return null;
            }
            else {
                return cached;
            }
        }
        else {
            //查找我们的事务注解
            TransactionAttribute txAttr = computeTransactionAttribute(method, targetClass);
            //若解析出来的事务注解属性为空
            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.isDebugEnabled()) {
                    logger.debug("Adding transactional method '" + methodIdentification + "' with attribute: " + txAttr);
                }
                //加入到缓存
                this.attributeCache.put(cacheKey, txAttr);
            }
            return txAttr;
        }
    }

　　进入查找我们的事务注解，computeTransactionAttribute(method, targetClass)方法：

protected TransactionAttribute computeTransactionAttribute(Method method, @Nullable Class targetClass) {
        //判断我们的事务方法上的修饰符是不是public的
        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 = AopUtils.getMostSpecificMethod(method, targetClass);

        //第一：先去目标对象的方法上去找我们的事务注解
        TransactionAttribute txAttr = findTransactionAttribute(specificMethod);
        if (txAttr != null) {
            return txAttr;
        }

        //第二：去目标对象上找事务注解
        txAttr = findTransactionAttribute(specificMethod.getDeclaringClass());
        if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
            return txAttr;
        }

        if (specificMethod != method) {
            //第三：去我们的实现类的接口上的方法去找事务注解
            txAttr = findTransactionAttribute(method);
            if (txAttr != null) {
                return txAttr;
            }
            //第四：去我们的实现类的接口上去找事务注解
            txAttr = findTransactionAttribute(method.getDeclaringClass());
            if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
                return txAttr;
            }
        }

        return null;
    }

　　进入到找@Transactional注解，findTransactionAttribute(specificMethod)方法：

 　　进入determineTransactionAttribute(method)方法：

protected TransactionAttribute determineTransactionAttribute(AnnotatedElement element) {
        //获取我们的注解解析器
        for (TransactionAnnotationParser annotationParser : this.annotationParsers) {
            //通过注解解析器去解析我们的元素(方法或者类)上的注解
            TransactionAttribute attr = annotationParser.parseTransactionAnnotation(element);
            if (attr != null) {
                return attr;
            }
        }
        return null;
    }

　　进入annotationParser.parseTransactionAnnotation(element)方法：

public TransactionAttribute parseTransactionAnnotation(AnnotatedElement element) {
        //从element对象中获取@Transactional注解 然后把注解属性封装到了AnnotationAttributes
        AnnotationAttributes attributes = AnnotatedElementUtils.findMergedAnnotationAttributes(
                element, Transactional.class, false, false);
        if (attributes != null) {
            //解析出真正的事务属性对象
            return parseTransactionAnnotation(attributes);
        }
        else {
            return null;
        }
    }

　　进入到解析出真正的事务属性对象，parseTransactionAnnotation(attributes)方法：

protected TransactionAttribute parseTransactionAnnotation(AnnotationAttributes attributes) {
        //创建一个基础规则的事务属性对象
        RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();
        //解析@Transactionl上的传播行为
        Propagation propagation = attributes.getEnum("propagation");
        rbta.setPropagationBehavior(propagation.value());
        //解析@Transactionl上的隔离级别
        Isolation isolation = attributes.getEnum("isolation");
        rbta.setIsolationLevel(isolation.value());
        //解析@Transactionl上的事务超时事件
        rbta.setTimeout(attributes.getNumber("timeout").intValue());
        rbta.setReadOnly(attributes.getBoolean("readOnly"));
        //解析@Transactionl上的事务管理器的名称
        rbta.setQualifier(attributes.getString("value"));

        //解析针对哪种异常回滚
        List rollbackRules = new ArrayList<>();
        for (Class rbRule : attributes.getClassArray("rollbackFor")) {
            rollbackRules.add(new RollbackRuleAttribute(rbRule));
        }
        //对哪种异常进行回滚
        for (String rbRule : attributes.getStringArray("rollbackForClassName")) {
            rollbackRules.add(new RollbackRuleAttribute(rbRule));
        }
        //对哪种异常不回滚
        for (Class rbRule : attributes.getClassArray("noRollbackFor")) {
            rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
        }
        //对哪种类型不回滚
        for (String rbRule : attributes.getStringArray("noRollbackForClassName")) {
            rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
        }
        rbta.setRollbackRules(rollbackRules);

        return rbta;
    }

 　　至此computeTransactionAttribute(method, targetClass)方法执行完毕！！！

 　　然后把我们执行方法的描述符设置到TransactionAttribute事务属性中，表示该方法需要执行Spring事务，并把事务注解属性加入到缓存attributeCache中，至此获取事务注解属性tas.getTransactionAttribute完毕！！！

　　如果canApply方法返回true表示找到真正能用的增强器了，然后就把合适的增强器加入到eligibleAdvisors中：

 　　至此findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName)执行完毕！！！

 　　③ extendAdvisors(eligibleAdvisors) 扩展增强器

　　 ④ sortAdvisors(eligibleAdvisors) 排序

　　其中③，④ 略 具体参考Spring系列（五）：Spring AOP源码解析，其实事务找增强器相对Aop简单很多，到此findEligibleAdvisors(beanClass, beanName)执行完毕！！！

 　　到此Spring事务创建代理对象完毕！！！

 四、Spring事务代理调用过程

 　　第一步：执行addUser(user)方法

　　其实就是调用org.springframework.aop.framework.JdkDynamicAopProxy#invoke

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object oldProxy = null;
        boolean setProxyContext = false;
        //获取到我们的目标对象
        TargetSource targetSource = this.advised.targetSource;
        Object target = null;

        try {
            //若是equals方法不需要代理
            if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
                // The target does not implement the equals(Object) method itself.
                return equals(args[0]);
            }
            //若是hashCode方法不需要代理
            else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
                // The target does not implement the hashCode() method itself.
                return hashCode();
            }
            //若是DecoratingProxy也不要拦截器执行
            else if (method.getDeclaringClass() == DecoratingProxy.class) {
                // There is only getDecoratedClass() declared -> dispatch to proxy config.
                return AopProxyUtils.ultimateTargetClass(this.advised);
            }
            else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
                    method.getDeclaringClass().isAssignableFrom(Advised.class)) {
                // Service invocations on ProxyConfig with the proxy config...
                return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
            }

            Object retVal;

            /**
             * 这个配置是暴露我们的代理对象到线程变量中，需要搭配@EnableAspectJAutoProxy(exposeProxy = true)一起使用
　　　　　　　 * 比如在目标对象方法中再次获取代理对象可以使用这个AopContext.currentProxy()
             * 还有的就是事务方法调用事务方法的时候也是用到这个
             */
            if (this.advised.exposeProxy) {
                //把我们的代理对象暴露到线程变量中
                oldProxy = AopContext.setCurrentProxy(proxy);
                setProxyContext = true;
            }

            //获取我们的目标对象
            target = targetSource.getTarget();
            //获取我们目标对象的class
            Class targetClass = (target != null ? target.getClass() : null);

            //把aop的advisor转化为拦截器链
            List