Spring源码 - 事务

• 解析 annotation-driven 标签(spring-tx 下 AnnotationDrivenBeanDefinitionParser.parse(element, parserContext))
  • 配置自动代理创建者
    • 注册 InfrastructureAdvisorAutoProxyCreator bean

        AopNamespaceUtils.registerAutoProxyCreatorIfNecessary(parserContext, element) 
        
        AopConfigUtils.registerAutoProxyCreatorIfNecessary(
        				parserContext.getRegistry(), parserContext.extractSource(sourceElement));
        				
        registerOrEscalateApcAsRequired(InfrastructureAdvisorAutoProxyCreator.class, registry, source);
        
        String AUTO_PROXY_CREATOR_BEAN_NAME = "org.springframework.aop.config.internalAutoProxyCreator";
        RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
        registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
    

    • InfrastructureAdvisorAutoProxyCreator 继承自AbstractAutoProxyCreator，间接实现了BeanPostProcessor接口，
      实现方法作为Aop后置处理方法入口(获取代理增强器 Advisor、获取代理对象)
  • 解析注册 Advisor beanDefinition
    • 解析 BeanFactoryTransactionAttributeSourceAdvisor 为 advisorDefinition 并注册

        RootBeanDefinition advisorDef = new RootBeanDefinition(BeanFactoryTransactionAttributeSourceAdvisor.class);
    

    • 将 TransactionInterceptor、AnnotationTransactionAttributeSource设置为advisorDefinition的属性

        //TransactionInterceptor
        String TRANSACTION_ADVISOR_BEAN_NAME = "org.springframework.transaction.config.internalTransactionAdvisor";
        String txAdvisorBeanName = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME;
        
        RootBeanDefinition interceptorDef = new RootBeanDefinition(TransactionInterceptor.class);
        String interceptorName = parserContext.getReaderContext().registerWithGeneratedName(interceptorDef);
        advisorDef.getPropertyValues().add("adviceBeanName", interceptorName);
        
        //AnnotationTransactionAttributeSource
        RootBeanDefinition sourceDef = new RootBeanDefinition("org.springframework.transaction.annotation.AnnotationTransactionAttributeSource");
        String sourceName = parserContext.getReaderContext().registerWithGeneratedName(sourceDef);
        advisorDef.getPropertyValues().add("transactionAttributeSource", new RuntimeBeanReference(sourceName));
        
        //registerBeanDefinition key: internalTransactionAdvisor value: BeanFactoryTransactionAttributeSourceAdvisor(transactionAttributeSource、adviceBeanName)
        parserContext.getRegistry().registerBeanDefinition(txAdvisorBeanName, advisorDef);
    

    • BeanFactoryTransactionAttributeSourceAdvisor、TransactionInterceptor 都是Advice的实现类，在获取Advisors时被加载
• 后置处理 - 增强器获取、代理类创建
  • 解析标签过程中注册的代理创建者 InfrastructureAdvisorAutoProxyCreator 的父类 AbstractAutoProxyCreator 实现了BeanPostProcessor接口,
    实现方法中调用了获取 Advisor、代理对象 的方法，BeanPostProcessor 接口方法会在bean加载完成后调用

      //AbstractAutowireCapableBeanFactory bean加载过程 - 调用 init()方法
      protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
          ...
      	if (mbd == null || !mbd.isSynthetic()) {
      		wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
      	}
      	return wrappedBean;
      }
      //AbstractAutowireCapableBeanFactory 后置处理
      public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException {
          ...
          //循环所有BeanPostProcessor实现类 调用重写方法
      	for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
      		result = beanProcessor.postProcessAfterInitialization(result, beanName);
      		...
      	}
      	return result;
      }
      //AbstractAutoProxyCreator 获取 Advisor、代理对象 的方法
      public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
      	if (bean != null) {
      	    ...
      		if (!this.earlyProxyReferences.contains(cacheKey)) {
      			return wrapIfNecessary(bean, beanName, cacheKey);
      		}
      	}
      	return bean;
      }
  
  

  • 查找 Advisors （AnnotationAwareAspectJAutoProxyCreator 实例）
    • 查找 Advisor 类型对象（事务advisor BeanFactoryTransactionAttributeSourceAdvisor）

        //AbstractAutoProxyCreator 
        protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
            ...
        	// Create proxy if we have advice.
        	Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
        	...
        }
        //AbstractAdvisorAutoProxyCreator
        protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
            //查找所有的Advisors AnnotationAwareAspectJAutoProxyCreator 实例方法
        	List<Advisor> candidateAdvisors = findCandidateAdvisors(beanName);
        	//查找可用的Advisors
        	List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
        	...
        	return eligibleAdvisors;
        }
        //AnnotationAwareAspectJAutoProxyCreator
        protected List<Advisor> findCandidateAdvisors(String beanName) {
        	//查找所有 Advisor 类 AnnotationAwareAspectJAutoProxyCreator父类AnnotationAwareAspectJAutoProxyCreator的方法
        	List<Advisor> advisors = super.findCandidateAdvisors(beanName);
        	//从所有 bean 中查找标记有 @Aspect 注解的类
            advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
            return advisors;
        }
        //AbstractAdvisorAutoProxyCreator
        protected List<Advisor> findCandidateAdvisors(String beanName) {
            List<Advisor> list = this.advisorRetrievalHelper.findAdvisorBeans();
            return list;
        }    
        //BeanFactoryAdvisorRetrievalHelper
        public List<Advisor> findAdvisorBeans() {
        	String[] advisorNames = null;
        	synchronized (this) {
        	    advisorNames = this.cachedAdvisorBeanNames;
        	    if (advisorNames == null) {
                    /*
                    * 获取 Advisor 类型的bean 前面解析标签时有解析到 BeanFactoryTransactionAttributeSourceAdvisor、
                    * TransactionInterceptor、AnnotationTransactionAttributeSource
                    * */
        	        advisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this.beanFactory, Advisor.class, true, false);
        	        this.cachedAdvisorBeanNames = advisorNames;
        	    }
        	}
        	...
        }
    

    • 查找标记有 @Aspect 注解对象（aop） 获取到 Aspect 类的所有增强方法（@Before、@AfterReturning等注解标注的方法） 封装 Advisors 对象

        //AnnotationAwareAspectJAutoProxyCreator
        protected List<Advisor> findCandidateAdvisors(String beanName) {
        	...
        	//从所有 bean 中查找标记有 @Aspect 注解的类
            advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
            return advisors;
        }
        //BeanFactoryAspectJAdvisorsBuilder
        public List<Advisor> buildAspectJAdvisors() {
            ...
            //遍历已加载的所有bean
            for (String beanName : beanNames) {
                //判断 bean 是否有 Aspect注解
                if (this.advisorFactory.isAspect(beanType)) {
                    aspectNames.add(beanName);
                    ...
                        //解析 Aspect bean 的方法 判断方法是否有Before, Around, After, AfterReturning, AfterThrowing, Pointcut 等注解
                        List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);
                        ...
                        advisors.addAll(classAdvisors);
                    ...
                }
            }
            ...
        }
        // @Aspect注解校验
        @Override
        public boolean isAspect(Class<?> clazz) {
        	return (hasAspectAnnotation(clazz) && !compiledByAjc(clazz));
        }
        private boolean hasAspectAnnotation(Class<?> clazz) {
        	return (AnnotationUtils.findAnnotation(clazz, Aspect.class) != null);
        }
        
        //ReflectiveAspectJAdvisorFactory
        @Override
        public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory) {
        	...
        	//遍历 Aspect 的所有方法 排除了@Pointcut注解的方法
        	for (Method method : getAdvisorMethods(aspectClass)) {
        	    //获取 Aspect 的所有通知方法 @Before、@AfterReturning等注解标注的方法
        		Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, advisors.size(), aspectName);
        		if (advisor != null) {
        			advisors.add(advisor);
        		}
        	}
            ...
        	return advisors;
        }
        @Override
        public Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aspectInstanceFactory,
        		int declarationOrderInAspect, String aspectName) {
            //判断方法的aop通知方式 Before、Around、After 、、、
        	AspectJExpressionPointcut expressionPointcut = getPointcut(
        			candidateAdviceMethod, aspectInstanceFactory.getAspectMetadata().getAspectClass());
            //封装advisor对象
        	return new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod,
        			this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
        }
        
        private AspectJExpressionPointcut getPointcut(Method candidateAdviceMethod, Class<?> candidateAspectClass) {
        	AspectJAnnotation<?> aspectJAnnotation =
        			AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
        	...
        }
        protected static AspectJAnnotation<?> findAspectJAnnotationOnMethod(Method method) {
        	Class<?>[] classesToLookFor = new Class<?>[] {
        			Before.class, Around.class, After.class, AfterReturning.class, AfterThrowing.class, Pointcut.class};
        	for (Class<?> c : classesToLookFor) {
        		AspectJAnnotation<?> foundAnnotation = findAnnotation(method, (Class<Annotation>) c);
        		if (foundAnnotation != null) {
        			return foundAnnotation;
        		}
        	}
        	return null;
        }
        //InstantiationModelAwarePointcutAdvisorImpl 
        public InstantiationModelAwarePointcutAdvisorImpl(AspectJExpressionPointcut declaredPointcut,
        	...
        	//初始化Advisors
        	this.instantiatedAdvice = instantiateAdvice(this.declaredPointcut);
        	...
        }
        private Advice instantiateAdvice(AspectJExpressionPointcut pcut) {
        	return this.aspectJAdvisorFactory.getAdvice(this.aspectJAdviceMethod, pcut,
        			this.aspectInstanceFactory, this.declarationOrder, this.aspectName);
        }
        //ReflectiveAspectJAdvisorFactory 
        @Override
        public Advice getAdvice(Method candidateAdviceMethod, AspectJExpressionPointcut expressionPointcut,
        		MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) {
        	...
        	//按通知方式封装 AbstractAspectJAdvice
        	AbstractAspectJAdvice springAdvice;
        	switch (aspectJAnnotation.getAnnotationType()) {
        		case AtBefore:
        			springAdvice = new AspectJMethodBeforeAdvice(
        					candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
        			break;
        		case AtAfter:
        			springAdvice = new AspectJAfterAdvice(
        					candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
        			break;
        		case AtAfterReturning:
        			springAdvice = new AspectJAfterReturningAdvice(
        					candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
        			AfterReturning afterReturningAnnotation = (AfterReturning) aspectJAnnotation.getAnnotation();
        			if (StringUtils.hasText(afterReturningAnnotation.returning())) {
        				springAdvice.setReturningName(afterReturningAnnotation.returning());
        			}
        			break;
        		case AtAfterThrowing:
        			springAdvice = new AspectJAfterThrowingAdvice(
        					candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
        			AfterThrowing afterThrowingAnnotation = (AfterThrowing) aspectJAnnotation.getAnnotation();
        			if (StringUtils.hasText(afterThrowingAnnotation.throwing())) {
        				springAdvice.setThrowingName(afterThrowingAnnotation.throwing());
        			}
        			break;
        		case AtAround:
        			springAdvice = new AspectJAroundAdvice(
        					candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
        			break;
        		case AtPointcut:
        			if (logger.isDebugEnabled()) {
        				logger.debug("Processing pointcut '" + candidateAdviceMethod.getName() + "'");
        			}
        			return null;
        		default:
        			throw new UnsupportedOperationException(
        					"Unsupported advice type on method: " + candidateAdviceMethod);
        	}
        	...
        	return springAdvice;
        }
    

    • 获取bean可用的 Advisors

        public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) {
        	if (advisor instanceof PointcutAdvisor) {
        		PointcutAdvisor pca = (PointcutAdvisor) advisor;
        		// BeanFactoryTransactionAttributeSourceAdvisor.pointcut --> TransactionAttributeSourcePointcut 
        		return canApply(pca.getPointcut(), targetClass, hasIntroductions);
        	}
        }
        //BeanFactoryTransactionAttributeSourceAdvisor
        private final TransactionAttributeSourcePointcut pointcut = new TransactionAttributeSourcePointcut() {
        	@Override
        	protected TransactionAttributeSource getTransactionAttributeSource() {
        		return transactionAttributeSource;
        	}
        }
        //TransactionAttributeSourcePointcut
        public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) {
            //TransactionAttributeSourcePointcut.getMethodMatcher() ---> this
        	MethodMatcher methodMatcher = pc.getMethodMatcher();
        	...
        	//遍历当前bean以及接口的的方法
        	Set<Class<?>> classes = new LinkedHashSet<Class<?>>(ClassUtils.getAllInterfacesForClassAsSet(targetClass));
        	classes.add(targetClass);
        	for (Class<?> clazz : classes) {
        		Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
        		for (Method method : methods) {
        		    //判断方法是否含有对应注解
        			if ((introductionAwareMethodMatcher != null && methodMatcher.matches(method, targetClass)) {
        				return true;
        			}
        		}
        	}
        	return false;
        }
        //TransactionAttributeSourcePointcut
        public boolean matches(Method method, Class<?> targetClass) {
        	...
        	TransactionAttributeSource tas = getTransactionAttributeSource();
        	//判断方法注解、解析配置（隔离级别的）
        	return (tas == null || tas.getTransactionAttribute(method, targetClass) != null);
        }
        //AbstractFallbackTransactionAttributeSource
        public TransactionAttribute getTransactionAttribute(Method method, Class<?> targetClass) {
        	...
        	//获取注解配置
        	TransactionAttribute txAttr = computeTransactionAttribute(method, targetClass);
        	//放入缓存
        	if (txAttr == null) {
            	this.attributeCache.put(cacheKey, NULL_TRANSACTION_ATTRIBUTE);
            }
        	...
        	return txAttr;
        }
        protected TransactionAttribute computeTransactionAttribute(Method method, Class<?> targetClass) {
        	...
        	//查找方法注解
        	TransactionAttribute txAttr = findTransactionAttribute(specificMethod);
        	...
        }
        //AnnotationTransactionAttributeSource
        protected TransactionAttribute findTransactionAttribute(Method method) {
        	return determineTransactionAttribute(method);
        }
        protected TransactionAttribute determineTransactionAttribute(AnnotatedElement ae) {
            if (ae.getAnnotations().length > 0) {
                //遍历注解解析器 解析注解
                for (TransactionAnnotationParser annotationParser : this.annotationParsers) {
                    TransactionAttribute attr = annotationParser.parseTransactionAnnotation(ae);
                    if (attr != null) {
                        return attr;
                    }
                }
            }
            return null;
        }
        public AnnotationTransactionAttributeSource(boolean publicMethodsOnly) {
        	...
        	this.annotationParsers = new LinkedHashSet<TransactionAnnotationParser>(2);
        	//加入spring解析器
        	this.annotationParsers.add(new SpringTransactionAnnotationParser());
        	...
        }
        //SpringTransactionAnnotationParser
        public TransactionAttribute parseTransactionAnnotation(AnnotatedElement ae) {
            //获取方法上 @Transactional 注解
        	AnnotationAttributes attributes = AnnotatedElementUtils.getMergedAnnotationAttributes(ae, Transactional.class);
        	if (attributes != null) {
        	    //解析事务隔离级别、回滚机制等
        		return parseTransactionAnnotation(attributes);
        	}
        	else {
        		return null;
        	}
        }
        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"));
        	ArrayList<RollbackRuleAttribute> rollBackRules = new ArrayList<RollbackRuleAttribute>();
        	Class<?>[] rbf = attributes.getClassArray("rollbackFor");
        	for (Class<?> rbRule : rbf) {
        		RollbackRuleAttribute rule = new RollbackRuleAttribute(rbRule);
        		rollBackRules.add(rule);
        	}
        	String[] rbfc = attributes.getStringArray("rollbackForClassName");
        	for (String rbRule : rbfc) {
        		RollbackRuleAttribute rule = new RollbackRuleAttribute(rbRule);
        		rollBackRules.add(rule);
        	}
        	Class<?>[] nrbf = attributes.getClassArray("noRollbackFor");
        	for (Class<?> rbRule : nrbf) {
        		NoRollbackRuleAttribute rule = new NoRollbackRuleAttribute(rbRule);
        		rollBackRules.add(rule);
        	}
        	String[] nrbfc = attributes.getStringArray("noRollbackForClassName");
        	for (String rbRule : nrbfc) {
        		NoRollbackRuleAttribute rule = new NoRollbackRuleAttribute(rbRule);
        		rollBackRules.add(rule);
        	}
        	rbta.getRollbackRules().addAll(rollBackRules);
        	return rbta;
        }