AOP切面类解析

Spring AOP是通过给一个类加上@Aspect注解来定义一个切面类，定义一个Pointcut方法，最后定义一系列的增强方法，这样就完成一个对象的切面操作。

通过@EnableAspectJAutoProxy注解开启AOP切面，该注解类上@Import(AspectJAutoProxyRegistrar.class)注解中AspectJAutoProxyRegistrar实现了ImportBeanDefinitionRegistrar，其会通过registerBeanDefinitions方法为容器导入为Bean创建代理beanName为internalAutoProxyCreator的关键beanDefinition。type为AnnotationAwareAspectJAutoProxyCreator。

@Import中ImportBeanDefinitionRegistrar接口registerBeanDefinitions方法调用时机是在invokeBeanFactoryPostProcessors的invokeBeanFactoryPostProcessors中解析完配置类后调用ConfigurationClassBeanDefinitionReader的loadBeanDefinitions方法，即在Bean实例化之前。

class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
   @Override
   public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
      // 注册名字internalAutoProxyCreator的AnnotationAwareAspectJAutoProxyCreator
      AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
      // 获得注解的属性
      AnnotationAttributes enableAspectJAutoProxy = AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
      // 根据其中的proxyTargetClass/exposeProxy设置beanDefinition属性
      if (enableAspectJAutoProxy != null) {
         if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
            AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
         }
         if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
            AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
         }
      }
   }
}

public abstract class AopConfigUtils {
    public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) {
        return registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry, null);
    }
    public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, @Nullable Object source) {
        return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
    }
    private static BeanDefinition registerOrEscalateApcAsRequired(Class<?> cls, BeanDefinitionRegistry registry, @Nullable Object source) {
        Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
        if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
            BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
            if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
                int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
                int requiredPriority = findPriorityForClass(cls);
                if (currentPriority < requiredPriority) {
                    apcDefinition.setBeanClassName(cls.getName());
                }
            }
            return null;
        }
        RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
        beanDefinition.setSource(source);
        beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
        beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
        registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
        return beanDefinition;
    }
}

在finishBeanFactoryInitialization第一个Bean创建时通过resolveBeforeInstantiation第一次调用后置处理器时，调用AnnotationAwareAspectJAutoProxyCreator超类AbstractAutoProxyCreator中的postProcessBeforeInstantiation方法时，对所有的AOP切面类进行解析并将解析后的Advisors列表缓存。

public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        Object cacheKey = getCacheKey(beanClass, beanName); // 构建缓存key
        // 没有beanName或没有包含在targetSourcedBeans中，一般都不会包含，因为targetSource需要手动设置，一般情况不会设置
        if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
            if (this.advisedBeans.containsKey(cacheKey)) { // 被解析过 直接返回
                return null;
            }
            // 判断是不是基础的bean即是不是切面类、通知、切点等，判断是不是应该跳过 默认false，切面解析也在其中
            if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
                this.advisedBeans.put(cacheKey, Boolean.FALSE);
                return null;
            }
        }
        // TargetSource代理逻辑的实现，在创建代理时默认是SingletonTargetSource，故若指定了TargetSource说明有自己的代理逻辑实现，在这就直接创建代理
        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;
    }
}

通过isInfrastructureClass判断该类是否是切面类、通知、切点等，判断逻辑就是判断当前正在创建的类是否为Advice、Pointcut、Advisor、AopInfrastructureBean的子类，若是则直接跳过解析。或若该类上有@Aspect注解且不是一个被AspectJ编译过的类也跳过解析。

public class AnnotationAwareAspectJAutoProxyCreator extends AspectJAwareAdvisorAutoProxyCreator {
    protected boolean isInfrastructureClass(Class<?> beanClass) {
        return (super.isInfrastructureClass(beanClass) || (this.aspectJAdvisorFactory != null && this.aspectJAdvisorFactory.isAspect(beanClass)));
    }
}
public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {
    private static final String AJC_MAGIC = "ajc$";
    protected boolean isInfrastructureClass(Class<?> beanClass) {
        // 若当前正在创建的Bean的class是Advice PointCut Advisor AopInfrastructureBean，直接跳过不需要解析
        boolean retVal = Advice.class.isAssignableFrom(beanClass) || Pointcut.class.isAssignableFrom(beanClass) || Advisor.class.isAssignableFrom(beanClass) || AopInfrastructureBean.class.isAssignableFrom(beanClass);
        return retVal;
    }
    public boolean isAspect(Class<?> clazz) { // 有没有切面注解 && 没有被AspectJ编译过
        return (hasAspectAnnotation(clazz) && !compiledByAjc(clazz));
    }
    private boolean hasAspectAnnotation(Class<?> clazz) {
        return (AnnotationUtils.findAnnotation(clazz, Aspect.class) != null);
    }
    private boolean compiledByAjc(Class<?> clazz) {
        for (Field field : clazz.getDeclaredFields()) {
            if (field.getName().startsWith(AJC_MAGIC)) { 
                return true; // 至少一个属性前缀为"ajc$"
            }
        }
        return false;
    }
}

shouldSkip中的findCandidateAdvisors()会解析出所有的Advisor，这里的AspectJPointcutAdvisor是xml中advisor解析的对象，若aspect是当前beanName就说明当前bean是切面类则跳过。

public class AspectJAwareAdvisorAutoProxyCreator extends AbstractAdvisorAutoProxyCreator {
    protected boolean shouldSkip(Class<?> beanClass, String beanName) {
       List<Advisor> candidateAdvisors = findCandidateAdvisors(); // 找到所有定义的候选Advisors
       for (Advisor advisor : candidateAdvisors) {
          // AspectJPointcutAdvisor是xml<aop:advisor解析的对象，若<aop:aspect ref="beanName">是当前beanName就说明当前bean是切面类则跳过。
          if (advisor instanceof AspectJPointcutAdvisor && ((AspectJPointcutAdvisor) advisor).getAspectName().equals(beanName)) {
             return true;
          }
       }
       return super.shouldSkip(beanClass, beanName);
    }
}

通过buildAspectJAdvisors去容器中获取所有切面信息保存到缓存中。

public class AnnotationAwareAspectJAutoProxyCreator extends AspectJAwareAdvisorAutoProxyCreator {
    protected List<Advisor> findCandidateAdvisors() {
        // 找出xml配置的Advisor、原生接口的AOP的Advisor、事务相关的advisor
        List<Advisor> advisors = super.findCandidateAdvisors();
        if (this.aspectJAdvisorsBuilder != null) { // 找出Aspect相关的信息之后封装为一个advisor
            advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
        }
        return advisors; // 返回所有的通知
    }
}

关于advisorRetrievalHelper的初始化，AbstractAdvisorAutoProxyCreator的父类AbstractAutoProxyCreator实现了BeanFactoryAware接口，而AbstractAutoProxyCreator是事务和AOP导入进来的后置处理器的顶级父类，在实例化AOP和事务导入组件时会调用setBeanFactory的方法来注入Bean工厂，调用setBeanFactory会触发initBeanFactory的调用来实例化通知查找探测器。

public abstract class AbstractAdvisorAutoProxyCreator extends AbstractAutoProxyCreator {
    private BeanFactoryAdvisorRetrievalHelper advisorRetrievalHelper;
    protected List<Advisor> findCandidateAdvisors() { // 通过通知者探测器帮助找到通知
        Assert.state(this.advisorRetrievalHelper != null, "No BeanFactoryAdvisorRetrievalHelper available");
        return this.advisorRetrievalHelper.findAdvisorBeans();
    }
    public void setBeanFactory(BeanFactory beanFactory) {
        super.setBeanFactory(beanFactory);
        if (!(beanFactory instanceof ConfigurableListableBeanFactory)) {
            throw new IllegalArgumentException("AdvisorAutoProxyCreator requires a ConfigurableListableBeanFactory: " + beanFactory);
        }
        initBeanFactory((ConfigurableListableBeanFactory) beanFactory);
    }
    protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        this.advisorRetrievalHelper = new BeanFactoryAdvisorRetrievalHelperAdapter(beanFactory);
    }
}

探测器字段cachedAdvisorBeanNames是用来缓存Advisor全类名，在第一个单实例bean实例化过程中把所有的advisor名称解析出来，若cachedAdvisorBeanNames为空则先获取容器中所有实现了Advisor接口的实现类，典型为事务注解@EnableTransactionManagement导入ProxyTransactionManagementConfiguration配置类。

public class BeanFactoryAdvisorRetrievalHelper {
    public List<Advisor> findAdvisorBeans() {
        // 探测器字段cachedAdvisorBeanNames是用来缓存Advisor全类名，在第一个单实例bean实例化过程中把该advisor名称解析出来
        String[] advisorNames = this.cachedAdvisorBeanNames;
        if (advisorNames == null) {
            advisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this.beanFactory, Advisor.class, true, false);
            this.cachedAdvisorBeanNames = advisorNames;
        }
        if (advisorNames.length == 0) { // 若在容器中没有找到，直接返回一个空的集合
            return new ArrayList<>();
        }
        List<Advisor> advisors = new ArrayList<>();
        for (String name : advisorNames) { // 容器中找到了配置的BeanFactoryTransactionAttributeSourceAdvisor
            if (isEligibleBean(name)) { // 判断其是不是一个合适的
                if (this.beanFactory.isCurrentlyInCreation(name)) { // BeanFactoryTransactionAttributeSourceAdvisor是不是正在创建的bean
                } 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)) {
                                continue;
                            }
                        }
                        throw ex;
                    }
                }
            }
        }
        return advisors;
    }
}

缓存字段aspectNames没有值，会在AnnotationAwareAspectJAutoProxyCreator注册之后，第一个单例执行后置处理器时触发解析切面的操作。这里获取的是Object类型的Bean的名称即获取所有的Bean。遍历解析Advisor的过程十分耗性能，解析后会加入了保存切面信息的缓存，事务模块的功能是直接去容器中获取Advisor类型的，选择范围小，且不消耗性能，故事务模块中没有加入缓存来保存事务相关的advisor。

public List<Advisor> buildAspectJAdvisors() {
   // 用于保存切面的名称，该aspectNames是类级别的缓存，缓存已解析出的切面信息
   List<String> aspectNames = this.aspectBeanNames;
   if (aspectNames == null) {
      synchronized (this) { // 加上同步锁， 防止多线程同时加载Aspect
         aspectNames = this.aspectBeanNames;
         if (aspectNames == null) { // 双重检查加锁
            List<Advisor> advisors = new ArrayList<>(); // 保存所有通知的集合
            aspectNames = new ArrayList<>(); // 保存切面的名称的集合
            // 从容器中获取所有Bean，再遍历，该过程十分耗性能，解析后会加入了保存切面信息的缓存
            String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this.beanFactory, Object.class, true, false);
            for (String beanName : beanNames) { // 遍历从IOC容器中获取的所有bean的名称
               if (!isEligibleBean(beanName)) continue;
               Class<?> beanType = this.beanFactory.getType(beanName); // 通过beanName去容器中获取到对应class对象
               if (beanType == null) continue;
               if (this.advisorFactory.isAspect(beanType)) { // 根据class对象判断是不是切面
                  aspectNames.add(beanName); // 是切面类，加入到缓存中
                  // 把beanName和class对象构建成为一个AspectMetadata
                  AspectMetadata amd = new AspectMetadata(beanType, beanName);
                  if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
                     //构建切面注解的实例工厂
                     MetadataAwareAspectInstanceFactory factory = new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
                     // 真正的去获取通知对象
                     List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);
                     if (this.beanFactory.isSingleton(beanName)) { // 加入到缓存中
                        this.advisorsCache.put(beanName, classAdvisors);
                     } else {
                        this.aspectFactoryCache.put(beanName, factory);
                     }
                     advisors.addAll(classAdvisors);
                  } else {
                     if (this.beanFactory.isSingleton(beanName)) {
                        throw new IllegalArgumentException("Bean with name '" + beanName + "' is a singleton, but aspect instantiation model is not singleton");
                     }
                     MetadataAwareAspectInstanceFactory factory = new PrototypeAspectInstanceFactory(this.beanFactory, beanName);
                     this.aspectFactoryCache.put(beanName, factory);
                     advisors.addAll(this.advisorFactory.getAdvisors(factory));
                  }
               }
            }
            this.aspectBeanNames = aspectNames;
            return advisors;
         }
      }
   }
   if (aspectNames.isEmpty()) {
      return Collections.emptyList();
   }
   // 真正的创建切面的时候，我们不需要去解析了而是直接去缓存中获取处
   List<Advisor> advisors = new ArrayList<>();
   for (String aspectName : aspectNames) {
      List<Advisor> cachedAdvisors = this.advisorsCache.get(aspectName);
      if (cachedAdvisors != null) {
         advisors.addAll(cachedAdvisors);
      } else {
         MetadataAwareAspectInstanceFactory factory = this.aspectFactoryCache.get(aspectName);
         advisors.addAll(this.advisorFactory.getAdvisors(factory));
      }
   }
   return advisors;
}

遍历切面类中的所有除了被@Pointcut注解标注的方法，并将满足条件的每个方法都封装成一个Advisor。这里getAdvisorMethods方法中对所有获取到的切面方法按照Around、Before、After、AfterReturning、AfterThrowing的顺序进行了排序。

public class ReflectiveAspectJAdvisorFactory extends AbstractAspectJAdvisorFactory implements Serializable {
    public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory) {
        Class<?> aspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass(); // 获取标记为Aspect的类
        String aspectName = aspectInstanceFactory.getAspectMetadata().getAspectName(); // 获取切面类的名称
        validate(aspectClass); // 校验切面类
        // 使用包装模式来包装MetadataAwareAspectInstanceFactory构建为MetadataAwareAspectInstanceFactory
        MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory = new LazySingletonAspectInstanceFactoryDecorator(aspectInstanceFactory);
        List<Advisor> advisors = new ArrayList<>();
        // 获取到切面类中的所有方法，但是该方法不会解析标注了@PointCut注解的方法
        for (Method method : getAdvisorMethods(aspectClass)) { // 挨个去解析切面中的方法
            Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, advisors.size(), aspectName);
            if (advisor != null) {
                advisors.add(advisor);
            }
        }
        if (!advisors.isEmpty() && lazySingletonAspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {
            Advisor instantiationAdvisor = new SyntheticInstantiationAdvisor(lazySingletonAspectInstanceFactory);
            advisors.add(0, instantiationAdvisor);
        }
        for (Field field : aspectClass.getDeclaredFields()) {
            Advisor advisor = getDeclareParentsAdvisor(field);
            if (advisor != null) {
                advisors.add(advisor);
            }
        }
        return advisors;
    }
    public Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrderInAspect, String aspectName) {
        validate(aspectInstanceFactory.getAspectMetadata().getAspectClass());
        // 获得当前通知的切点表达式
        AspectJExpressionPointcut expressionPointcut = getPointcut(candidateAdviceMethod, aspectInstanceFactory.getAspectMetadata().getAspectClass());
        if (expressionPointcut == null) {
            return null;
        }
        // 将切点表达式和通知封装到InstantiationModelAwarePointcutAdvisorImpl对象中
        return new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod, this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
    }
    private AspectJExpressionPointcut getPointcut(Method candidateAdviceMethod, Class<?> candidateAspectClass) {
        // 找到aspectJ的注解：@Pointcut、@Around、@Before、@After、@AfterReturning、@AfterThrowing
        AspectJAnnotation<?> aspectJAnnotation = AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
        if (aspectJAnnotation == null) { // 没有注解直接忽略
            return null;
        }
        AspectJExpressionPointcut ajexp = new AspectJExpressionPointcut(candidateAspectClass, new String[0], new Class<?>[0]);
        ajexp.setExpression(aspectJAnnotation.getPointcutExpression());
        if (this.beanFactory != null) {
            ajexp.setBeanFactory(this.beanFactory);
        }
        return ajexp;
    }
    private List<Method> getAdvisorMethods(Class<?> aspectClass) {
        final List<Method> methods = new ArrayList<>();
        ReflectionUtils.doWithMethods(aspectClass, method -> {
            if (AnnotationUtils.getAnnotation(method, Pointcut.class) == null) {
                methods.add(method);
            }
        });
        methods.sort(METHOD_COMPARATOR);
        return methods;
    }
    private static final Comparator<Method> METHOD_COMPARATOR;
    static {
        Comparator<Method> adviceKindComparator = new ConvertingComparator<>(
            new InstanceComparator<>(Around.class, Before.class, After.class, AfterReturning.class, AfterThrowing.class),
            (Converter<Method, Annotation>) method -> {
                AspectJAnnotation<?> annotation = AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(method);
                return (annotation != null ? annotation.getAnnotation() : null);
            });
        Comparator<Method> methodNameComparator = new ConvertingComparator<>(Method::getName);
        METHOD_COMPARATOR = adviceKindComparator.thenComparing(methodNameComparator);
    }
}

找到方法上是否有@Pointcut、@Around、@Before、@After、@AfterReturning、@AfterThrowing等注解，并获取到注解上切面表达式。

public abstract class AbstractAspectJAdvisorFactory implements AspectJAdvisorFactory {
    private static final Class<?>[] ASPECTJ_ANNOTATION_CLASSES = new Class<?>[] {Pointcut.class, Around.class, Before.class, After.class, AfterReturning.class, AfterThrowing.class};
    protected static AspectJAnnotation<?> findAspectJAnnotationOnMethod(Method method) {
        for (Class<?> clazz : ASPECTJ_ANNOTATION_CLASSES) {
            AspectJAnnotation<?> foundAnnotation = findAnnotation(method, (Class<Annotation>) clazz);
            if (foundAnnotation != null) {
                return foundAnnotation;
            }
        }
        return null;
    }
}

通过InstantiationModelAwarePointcutAdvisorImpl的instantiateAdvice方法将不同类型的注解方法解析成对应的Advice。

class InstantiationModelAwarePointcutAdvisorImpl implements InstantiationModelAwarePointcutAdvisor, AspectJPrecedenceInformation, Serializable {
    public InstantiationModelAwarePointcutAdvisorImpl(AspectJExpressionPointcut declaredPointcut, Method aspectJAdviceMethod, AspectJAdvisorFactory aspectJAdvisorFactory, MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) {
        this.declaredPointcut = declaredPointcut;// 当前的切点
        this.declaringClass = aspectJAdviceMethod.getDeclaringClass();// 切面的class对象
        this.methodName = aspectJAdviceMethod.getName();// 切面方法的名称
        this.parameterTypes = aspectJAdviceMethod.getParameterTypes();// 切面方法的参数类型
        this.aspectJAdviceMethod = aspectJAdviceMethod;// 切面方法对象
        this.aspectJAdvisorFactory = aspectJAdvisorFactory;// aspectj的通知工厂
        this.aspectInstanceFactory = aspectInstanceFactory;// aspect的实例工厂
        this.declarationOrder = declarationOrder;// 切面的顺序
        this.aspectName = aspectName;// 切面的名称
        // 判断当前的切面对象是否需要延时加载
        if (aspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {
            Pointcut preInstantiationPointcut = Pointcuts.union(aspectInstanceFactory.getAspectMetadata().getPerClausePointcut(), this.declaredPointcut);
            this.pointcut = new PerTargetInstantiationModelPointcut(this.declaredPointcut, preInstantiationPointcut, aspectInstanceFactory);
            this.lazy = true;
        } else {
            this.pointcut = this.declaredPointcut;
            this.lazy = false;
            // 把切面中的通知构造为一个一个的advice通知对象
            this.instantiatedAdvice = instantiateAdvice(this.declaredPointcut);
        }
    }
    private Advice instantiateAdvice(AspectJExpressionPointcut pointcut) {
        Advice advice = this.aspectJAdvisorFactory.getAdvice(this.aspectJAdviceMethod, pointcut, this.aspectInstanceFactory, this.declarationOrder, this.aspectName);
        return (advice != null ? advice : EMPTY_ADVICE);
    }
}

在instantiateAdvice方法中调用getAdvice方法根据不同类型的注解生成对应的Advice。

public class ReflectiveAspectJAdvisorFactory extends AbstractAspectJAdvisorFactory implements Serializable {
    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);
        if (aspectJAnnotation == null) { // 解析出来的注解信息是否为null
            return null;
        }
        if (!isAspect(candidateAspectClass)) { // 判断这里的class对象是不是切面信息对象
            throw new AopConfigException("Advice must be declared inside an aspect type: Offending method '" + candidateAdviceMethod + "' in class [" + candidateAspectClass.getName() + "]");
        }
        AbstractAspectJAdvice springAdvice;
        switch (aspectJAnnotation.getAnnotationType()) { // 判断标注在方法上的注解类型
            case AtPointcut: // 是PointCut注解则抛出异常，在外面传递进来的方法已经排除了pointcut的方法
                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;
    }
}