AOP--切面解析源码

整体流程

按照箭头方向对每个方法的进行解析

resolveBeforeInstantiation

该方法并没有做什么特别的事情，只是对applyBeanPostProcessorsBeforeInstantiation方法进行了调用

bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);

applyBeanPostProcessorsBeforeInstantiation

获取容器中所有的后置处理器，通过调用getBeanPostProcessors，遍历所有的后置处理器，判断是不是InstantiationAwareBeanPostProcessor。如果是，进行强转成InstantiationAwareBeanPostProcessor，然后调用执行后置处理器的postProcessBeforeInstantiation方法。

for (BeanPostProcessor bp : getBeanPostProcessors()) {
   //判断后置处理器是不是InstantiationAwareBeanPostProcessor
   if (bp instanceof InstantiationAwareBeanPostProcessor) {
      //把我们的BeanPostProcessor强制转为InstantiationAwareBeanPostProcessor
      InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
      /**
       * 【很重要】
       * 我们AOP @EnableAspectJAutoProxy 为我们容器中导入了 AnnotationAwareAspectJAutoProxyCreator
       * 我们事务注解@EnableTransactionManagement 为我们的容器导入了 InfrastructureAdvisorAutoProxyCreator
       * 都是实现了我们的 BeanPostProcessor接口,InstantiationAwareBeanPostProcessor,
       * 进行后置处理解析切面
       */
      Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
      if (result != null) {
         return result;
      }
   }
}

postProcessBeforeInstantiation

该方法此处的实现是AbstractAutoProxyCreator，首先构建缓存key，

Object cacheKey = getCacheKey(beanClass, beanName);

判断是否被解析过了，然后判断是否是基础bean，进入shouldSkip

//以及被解析过 直接返回
if (this.advisedBeans.containsKey(cacheKey)) {
   return null;
}
if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
   this.advisedBeans.put(cacheKey, Boolean.FALSE);
   return null;
}

shouldSkip

调用findCandidateAdvisors返回增强器对象集合，

List<Advisor> candidateAdvisors = findCandidateAdvisors();

最后遍历增强器，满足

则返回true，一般是返回的false

findCandidateAdvisors

首先找出事物相关的advisor，这里为空，然后去调用buildAspectJAdvisors

@Override
protected List<Advisor> findCandidateAdvisors() {
   //找出事务相关的advisor
   List<Advisor> advisors = super.findCandidateAdvisors();
   //找出Aspect相关的信息之后封装为一个advisor
   if (this.aspectJAdvisorsBuilder != null) {
      advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
   }
   //返回我们所有的通知
   return advisors;
}

buildAspectJAdvisors

构建缓存，aspectNames，如果这个为空的话，说明当前需要出发aop的解析工作
经过dcl之后，构建出两个集合

获取容器中所有bean的名称
遍历beanName，通过名称去获取class对象，再根据class对象判断是否是切面，是，加入到aspectNames的缓存中，然后将beanName和class对象构建一个AspectMetadata对象。再构建一个切面注解的实例工厂

String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
      this.beanFactory, Object.class, true, false);
//遍历我们从IOC容器中获取处的所有bean的名称
for (String beanName : beanNames) {
    ...
    if (this.advisorFactory.isAspect(beanType)) {
       //是切面类
       //加入到缓存中
       aspectNames.add(beanName);
   }
}

然后去获取真正的通知对象调用getAdvisors方法

List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);

getAdvisors

获取切面类中所有的方法，通过getAdvisorMethods能过滤掉标注了@PointCut的方法，然后调用getAdvisor挨个去解析该类中的方法，并且返回一个advisor对象。

for (Method method : getAdvisorMethods(aspectClass)) {
   //挨个去解析我们切面中的方法,并且实例化返回一个advisor对象
   Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, advisors.size(), aspectName);
   if (advisor != null) {
      advisors.add(advisor);
   }
}

getAdvisor

AspectJExpressionPointcut expressionPointcut = getPointcut(
      candidateAdviceMethod, aspectInstanceFactory.getAspectMetadata().getAspectClass());

在切面的方法上构建切面表达式，这里能够将非advisor给过滤筛选出来
然后将我们的advisor实例化，调用InstantiationModelAwarePointcutAdvisorImpl

InstantiationModelAwarePointcutAdvisorImpl

这里最终会去调用getAdvice方法，将创建的advice和切点表达式一起构建出advisor对象

getAdvice

这里就是最终构建我们advisor的地方了，方法也挺简单的直接贴出源代码，到这里解析aop就算结束了## 标题

public Advice getAdvice(Method candidateAdviceMethod, AspectJExpressionPointcut expressionPointcut,
      MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) {

   //获取我们的切面类的class对象
   Class<?> candidateAspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
   validate(candidateAspectClass);

   //获取切面方法上的注解
   AspectJAnnotation<?> aspectJAnnotation =
         AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
   //解析出来的注解信息是否为null
   if (aspectJAnnotation == null) {
      return null;
   }

   //判断这里的class对象是不是切面信息对象
   if (!isAspect(candidateAspectClass)) {
      throw new AopConfigException("Advice must be declared inside an aspect type: " +
            "Offending method '" + candidateAdviceMethod + "' in class [" +
            candidateAspectClass.getName() + "]");
   }

   if (logger.isDebugEnabled()) {
      logger.debug("Found AspectJ method: " + candidateAdviceMethod);
   }

   AbstractAspectJAdvice springAdvice;

   //判断标注在方法上的注解类型
   switch (aspectJAnnotation.getAnnotationType()) {
      //是PointCut注解 那么就抛出异常 因为在外面传递进来的方法已经排除了pointcut的方法
      case AtPointcut:
         if (logger.isDebugEnabled()) {
            logger.debug("Processing pointcut '" + candidateAdviceMethod.getName() + "'");
         }
         return null;

      case AtAround:   //环绕通知 构建AspectJAroundAdvice
         springAdvice = new AspectJAroundAdvice(
               candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
         break;
      case AtBefore:  //前置通知  构建AspectJMethodBeforeAdvice
         springAdvice = new AspectJMethodBeforeAdvice(
               candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
         break;
      case AtAfter:  //后置通知 AspectJAfterAdvice
         springAdvice = new AspectJAfterAdvice(
               candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
         break;
      case AtAfterReturning: //返回通知 AspectJAfterReturningAdvice
         springAdvice = new AspectJAfterReturningAdvice(
               candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
         AfterReturning afterReturningAnnotation = (AfterReturning) aspectJAnnotation.getAnnotation();
         if (StringUtils.hasText(afterReturningAnnotation.returning())) {
            springAdvice.setReturningName(afterReturningAnnotation.returning());
         }
         break;
      case AtAfterThrowing:  //异常通知   AspectJAfterThrowingAdvice
         springAdvice = new AspectJAfterThrowingAdvice(
               candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
         AfterThrowing afterThrowingAnnotation = (AfterThrowing) aspectJAnnotation.getAnnotation();
         if (StringUtils.hasText(afterThrowingAnnotation.throwing())) {
            springAdvice.setThrowingName(afterThrowingAnnotation.throwing());
         }
         break;
      default:
         throw new UnsupportedOperationException(
               "Unsupported advice type on method: " + candidateAdviceMethod);
   }

   //配置我们构建出来的通知对象
   springAdvice.setAspectName(aspectName);
   springAdvice.setDeclarationOrder(declarationOrder);
   String[] argNames = this.parameterNameDiscoverer.getParameterNames(candidateAdviceMethod);
   if (argNames != null) {
      springAdvice.setArgumentNamesFromStringArray(argNames);
   }
   springAdvice.calculateArgumentBindings();

   return springAdvice;
}