SpringAOP——事务实现细节

    <!-- 事务管理 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!-- 启用声明式事务管理 支持注解@Transaction-->
    <tx:annotation-driven proxy-target-class="false" transaction-manager="transactionManager"/>

TransactionalEventListenerFactory
AnnotationTransactionAttributeSource
TransactionInterceptor//SpringAOP方法执行时的责任链拦截器
BeanFactoryTransactionAttributeSourceAdvisor//直接用bean创建的Advisor

/*  org.springframework.transaction.config.AnnotationDrivenBeanDefinitionParser#registerTransactionalEventListenerFactory */
    private void registerTransactionalEventListenerFactory(ParserContext parserContext) {
        //创建TransactionEvenListenerFactory的Beandefinition
        RootBeanDefinition def = new RootBeanDefinition();
        def.setBeanClass(TransactionalEventListenerFactory.class);
        parserContext.registerBeanComponent(new BeanComponentDefinition(def,
                TransactionManagementConfigUtils.TRANSACTIONAL_EVENT_LISTENER_FACTORY_BEAN_NAME));
    }

/* org.springframework.transaction.config.AnnotationDrivenBeanDefinitionParser.AopAutoProxyConfigurer#configureAutoProxyCreator */
public static void configureAutoProxyCreator(Element element, ParserContext parserContext) {
            //若未注册，先注册SpringAOP相关Beandefinition
            AopNamespaceUtils.registerAutoProxyCreatorIfNecessary(parserContext, element);

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

                //Source的Beandefinition
                //beanName = org.springframework.transaction.annotation.AnnotationTransactionAttributeSource#0
                RootBeanDefinition sourceDef = new RootBeanDefinition(
                        "org.springframework.transaction.annotation.AnnotationTransactionAttributeSource");
                //实际eleSource == null
                sourceDef.setSource(eleSource);
                sourceDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
                //sourceName == org.springframework.transaction.annotation.AnnotationTransactionAttributeSource#0
                String sourceName = parserContext.getReaderContext().registerWithGeneratedName(sourceDef);

                //Inteceptor的BeanDefinition
                //beanName=org.springframework.transaction.interceptor.TransactionInterceptor#0
                RootBeanDefinition interceptorDef = new RootBeanDefinition(TransactionInterceptor.class);
                interceptorDef.setSource(eleSource);
                interceptorDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
                //初始化时的重要信息，设置TransactionInterceptor的属性trancationManagerBeanName的beanName，初始化时依赖注入
                //实际获取<tx:annotation-driven transaction-manager="" >中的transaction-manage属性，默认值：beanName = transactionManager
                registerTransactionManager(element, interceptorDef);
                //TransactionInterception.trancationAttributeSource = AnnotationTransactionAttributeSource
                interceptorDef.getPropertyValues().add("transactionAttributeSource", new RuntimeBeanReference(sourceName));
                //interceptorName = org.springframework.transaction.interceptor.TransactionInterceptor#0
                String interceptorName = parserContext.getReaderContext().registerWithGeneratedName(interceptorDef);
                
                //advisor的BeanDefinition
                //beanName = org.springframework.transaction.config.internalTransactionAdvisor
                RootBeanDefinition advisorDef = new RootBeanDefinition(BeanFactoryTransactionAttributeSourceAdvisor.class);
                advisorDef.setSource(eleSource);
                advisorDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
                //设置两个属性
                //advisor.transactionAttributeSource = AnnotationTransactionAttributeSource的beanName
                //advisor.adviceBeanName = TransactionInterceptor的beanName
                advisorDef.getPropertyValues().add("transactionAttributeSource", new RuntimeBeanReference(sourceName));
                advisorDef.getPropertyValues().add("adviceBeanName", interceptorName);
                if (element.hasAttribute("order")) {
                    advisorDef.getPropertyValues().add("order", element.getAttribute("order"));
                }
                //将组件的BeanDefinition注册到DefaultListableBeanFactory中
                parserContext.getRegistry().registerBeanDefinition(txAdvisorBeanName, advisorDef);
                
                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);
            }
        }

//Inteceptor
TransactionInterceptor.trancationManagerBeanName = "transactionManager"
TransactionInterceptor.transactionAttributeSource = AnnotationTransactionAttributeSource
//advisor
advisor.transactionAttributeSource = AnnotationTransactionAttributeSource
advisor.advice = TransactionInterceptor 

/* org.springframework.transaction.interceptor.BeanFactoryTransactionAttributeSourceAdvisor#getPointcut */
    /*
    * BeanFactoryTransactionAttributeSourceAdvisor中的pointCut初始化
    */
    public Pointcut getPointcut() {
        return this.pointcut;
    }

    //pointCut实际是一个TransactionAttributeSourcePointcut实例
    private final TransactionAttributeSourcePointcut pointcut = new TransactionAttributeSourcePointcut() {
        @Override
        @Nullable
        protected TransactionAttributeSource getTransactionAttributeSource() {
            return transactionAttributeSource;
        }
    };

    protected TransactionAttributeSourcePointcut() {
        setClassFilter(new TransactionAttributeSourceClassFilter());
    }

    private class TransactionAttributeSourceClassFilter implements ClassFilter {
        //判断Bean是否是poincut的一个join point（切面关注点）
        @Override
        public boolean matches(Class<?> clazz) {
            if (TransactionalProxy.class.isAssignableFrom(clazz) ||
                    PlatformTransactionManager.class.isAssignableFrom(clazz) ||
                    PersistenceExceptionTranslator.class.isAssignableFrom(clazz)) {
                //三种基础类型直接返回false
                return false;
            }
            //这里tas就是上面设置的AnnotationTrancationAttributeSource
            TransactionAttributeSource tas = getTransactionAttributeSource();
            return (tas == null || tas.isCandidateClass(clazz));
        }
    }

/* org.springframework.transaction.annotation.AnnotationTransactionAttributeSource#isCandidateClass */
    public boolean isCandidateClass(Class<?> targetClass) {
        for (TransactionAnnotationParser parser : this.annotationParsers) {
            if (parser.isCandidateClass(targetClass)) {
                return true;
            }
        }
        return false;
    }

    //annotationParsers初始化
    //annotationParsers.add(new SpringTransactionAnnotationParser())
    //系统支持jta12时annotationParsers.add(new SpringTransactionAnnotationParser())
    //系统支持ejb3时this.annotationParsers.add(new Ejb3TransactionAnnotationParser());
    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 {
            this.annotationParsers = Collections.singleton(new SpringTransactionAnnotationParser());
        }
    }

    //默认的SpringTransactionAnnotationParse.isCandidateClass
    //判断类中包含@Transactional注解，
    public boolean isCandidateClass(Class<?> targetClass) {
        return AnnotationUtils.isCandidateClass(targetClass, Transactional.class);
    }

/* org.springframework.transaction.interceptor.TransactionInterceptor#invoke */
    public Object invoke(MethodInvocation invocation) throws Throwable {
        // target object可能为null，所以这里获取targetClass
        //如果存在targetObject时 targetClass = targetObject.getClass
        //如果不存在targetObject时 targetClass = null
        //注意了mybatis接口绑定技术是没有targetObject的，这里targetClass == null
        Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);

        // 事务执行 
        // 第三个参数lamda表达式：invocation.proceed()
        return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed);
    }