在Spring中事务的实现依赖的是AOP。而AOP需要注册Advisor（增强器）。而Advisor中需要包含Interceptor（Advice通知/拦截器）。下面代码完成事务增强器的注册。

Advisor中包含Pointcut和Advice/Interceptor。Pointcut决定一个类是否需要进行代理，而Advice决定一个类如何进行增强。

在SpringBoot2.x中，下列代码是注册事务的增强器。

Spring AOP自动代理，可以分为两大类型。
AbstractAutoProxyCreator后置处理器。创建AOP代理实际上会去Spring容器中寻找所有的Advisor类的bean。由AbstractAutoProxyCreator的具体子类去筛选出合格的Advisor后，使用Advisor中的Pointcut对普通Bean所有方法进行筛选。

我们要使用事务时，一般会先使用@EnableTransactionManagement注解，而在SpringBoot2.x中会默认使用该注解。该注解会注册InfrastructureAdvisorAutoProxyCreator后置增强器，该后置增强器会筛选出Spring容器中@Role(BeanDefinition.ROLE_INFRASTRUCTURE)的Advisor。

当然判断某类上存在注解时，可以将注解直接解析为对象并且缓存，防止在真正代理的时候再次解析，影响性能。

//该类是将Advisor注册到Spring容器中，而`AbstractAutoProxyCreator`子类会自动对普通Bean进行AOP代理。
@Configuration
public class ProxyTransactionManagementConfiguration extends AbstractTransactionManagementConfiguration {

    @Bean(name = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME)
    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor() {
        BeanFactoryTransactionAttributeSourceAdvisor advisor = new BeanFactoryTransactionAttributeSourceAdvisor();
        advisor.setTransactionAttributeSource(transactionAttributeSource());
        advisor.setAdvice(transactionInterceptor());
        if (this.enableTx != null) {
            advisor.setOrder(this.enableTx.<Integer>getNumber("order"));
        }
        return advisor;
    }

   //注解式事务的解析器对象（本文分析的重点）。
    @Bean
    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    public TransactionAttributeSource transactionAttributeSource() {
        return new AnnotationTransactionAttributeSource();
    }

    @Bean
    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    public TransactionInterceptor transactionInterceptor() {
        TransactionInterceptor interceptor = new TransactionInterceptor();
        interceptor.setTransactionAttributeSource(transactionAttributeSource());
        if (this.txManager != null) {
            interceptor.setTransactionManager(this.txManager);
        }
        return interceptor;
    }

}

在Spring中支持三个不同的事务注解：

• Spring事务注解：org.springframework.transaction.annotation.Transactional。
• JTA事务注解：javax.transaction.Transactional。
• EJB3事务注解：javax.ejb.TransactionAttribute。

上面三种形式都包含响应的注解类。所以具体的使用方式是不完全相同的。但是他们的目的是相同的。一般默认情况下，只包含Spring的事务注解。

public class AnnotationTransactionAttributeSource extends AbstractFallbackTransactionAttributeSource
        implements Serializable {

    private static final boolean jta12Present;

    private static final boolean ejb3Present;

    static {
        ClassLoader classLoader = AnnotationTransactionAttributeSource.class.getClassLoader();
        jta12Present = ClassUtils.isPresent("javax.transaction.Transactional", classLoader);
        ejb3Present = ClassUtils.isPresent("javax.ejb.TransactionAttribute", classLoader);
    }
    //判断是否只增强public方法
    private final boolean publicMethodsOnly;
    //事务注解解析器对象集合
    private final Set<TransactionAnnotationParser> annotationParsers;

    public AnnotationTransactionAttributeSource() {
        this(true);
    }

    public AnnotationTransactionAttributeSource(boolean publicMethodsOnly) {
        this.publicMethodsOnly = publicMethodsOnly;
        if (jta12Present || ejb3Present) {
            this.annotationParsers = new LinkedHashSet<>(4);
            this.annotationParsers.add(new SpringTransactionAnnotationParser());
            if (jta12Present) {
                this.annotationParsers.add(new JtaTransactionAnnotationParser());
            }
            if (ejb3Present) {
                this.annotationParsers.add(new Ejb3TransactionAnnotationParser());
            }
        }
        else {
            //一般情况下，只使用Spring的事务注解处理器
            this.annotationParsers = Collections.singleton(new SpringTransactionAnnotationParser());
        }
    }
    ...AnnotationTransactionAttributeSource的构造方法
     //解析类上的事务注解
    @Override
    @Nullable
    protected TransactionAttribute findTransactionAttribute(Class<?> clazz) {
        return determineTransactionAttribute(clazz);
    }
    //解析方法上的事务注解
    @Override
    @Nullable
    protected TransactionAttribute findTransactionAttribute(Method method) {
        return determineTransactionAttribute(method);
    }

    //使用注解解析器解析注解，将注解解析到TransactionAttribute 对象中。
    @Nullable
    protected TransactionAttribute determineTransactionAttribute(AnnotatedElement element) {
        for (TransactionAnnotationParser annotationParser : this.annotationParsers) {
            TransactionAttribute attr = annotationParser.parseTransactionAnnotation(element);
            if (attr != null) {
                return attr;
            }
        }
        return null;
    }
    @Override
    protected boolean allowPublicMethodsOnly() {
        return this.publicMethodsOnly;
    }
}

为什么只有public权限的方法才能被事务增强，是allowPublicMethodsOnly参数进行控制的。

在AbstractAutoProxyCreator（后置处理器）中完成了事务的代理，它会校验该类或者方法上是否存在Transactional的注解，并将注解解析为TransactionAttribute对象并缓存起来，供TransactionInterceptor事务属性的控制。

事务注解解析器——SpringTransactionAnnotationParser

解析事务注解的实现类。

public class SpringTransactionAnnotationParser implements TransactionAnnotationParser, Serializable {

    @Override
    @Nullable
    public TransactionAttribute parseTransactionAnnotation(AnnotatedElement element) {
       //AnnotatedElement 参数是Class<?>或者Method对象，即解析类或方法上的注解。
        AnnotationAttributes attributes = AnnotatedElementUtils.findMergedAnnotationAttributes(
                element, Transactional.class, false, false);
        if (attributes != null) {
            //解析注解为TransactionAttribute 对象
            return parseTransactionAnnotation(attributes);
        }
        else {
            return null;
        }
    }

    public TransactionAttribute parseTransactionAnnotation(Transactional ann) {
        return parseTransactionAnnotation(AnnotationUtils.getAnnotationAttributes(ann, false, false));
    }

    protected TransactionAttribute parseTransactionAnnotation(AnnotationAttributes attributes) {
        RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();
        //处理事务注解的属性，例如传播行为、隔离级别、超时时间、回滚策略等
        Propagation propagation = attributes.getEnum("propagation");
        rbta.setPropagationBehavior(propagation.value());
        Isolation isolation = attributes.getEnum("isolation");
        rbta.setIsolationLevel(isolation.value());
        rbta.setTimeout(attributes.getNumber("timeout").intValue());
        rbta.setReadOnly(attributes.getBoolean("readOnly"));
        rbta.setQualifier(attributes.getString("value"));

        List<RollbackRuleAttribute> 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;
    }
    ...
}