Spring AOP配置标签解析

超、凢脫俗 2022-05-14 07:38 205阅读 0赞

# 准备 #

*  `Spring版本：5.0.8`

# 解析过程 #

开启 `Spring AOP` 注解自动代理需要配置标签 `<aop:aspectj-autoproxy/>`，查看 `spring-aop:5.0.8.RELEASE\META-INF\spring.handlers` 文件，配置以下内容：

http\://www.springframework.org/schema/aop=org.springframework.aop.config.AopNamespaceHandler

下面以 `AopNamespaceHandler` 为入口，对解析过程源码进行分析

// AopNamespaceHandler
    public void init() {
        this.registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());
        // 注册aspectj-autoproxy解析器
        this.registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());
        this.registerBeanDefinitionDecorator("scoped-proxy", new ScopedProxyBeanDefinitionDecorator());
        this.registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
    }

通过 `AspectJAutoProxyBeanDefinitionParser. parse()` 对 `<aop:aspectj-autoproxy/>` 标签进行解析

// AspectJAutoProxyBeanDefinitionParser
    public BeanDefinition parse(Element element, ParserContext parserContext) {
    // 注册AspectJAnnotationAutoProxyCreator
        AopNamespaceUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(parserContext, element);
        // 针对子元素的解析
    this.extendBeanDefinition(element, parserContext);
        return null;
    }

// AopNamespaceUtils
    public static void registerAspectJAnnotationAutoProxyCreatorIfNecessary(ParserContext parserContext, Element sourceElement) {
        // 注册AspectJAnnotationAutoProxyCreator
        BeanDefinition beanDefinition = 
    AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(parserContext.getRegistry(), parserContext.extractSource(sourceElement));
    // 对proxy-target-class及expose-proxy属性的处理
        useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);
        // 注册组件并通知 便于监听器做进一步处理
    registerComponentIfNecessary(beanDefinition, parserContext);
    }

// AopConfigUtils
    public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, @Nullable Object source) {
        return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
    }

// AopConfigUtils
    private static BeanDefinition registerOrEscalateApcAsRequired(Class<?> cls, BeanDefinitionRegistry registry, @Nullable Object source) {
        Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
    // 如果已经存在自动代理创建器 且 存在的自动代理创建器与现在的不一致需要根据优先级来判断需要使用那一个
        if (registry.containsBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator")) {
            BeanDefinition apcDefinition = registry.getBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator");
            if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
            // 获取已存在自动代理创建器优先级
                int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
            // 获取本次要创建自动代理创建器优先级
                int requiredPriority = findPriorityForClass(cls);
            // 使用优先级高的自动代理创建器
                if (currentPriority < requiredPriority) {
                    apcDefinition.setBeanClassName(cls.getName());
                }
            }
            // 已存在自动代理创建器与将要创建的一致 则无需再次创建
            return null;
        } else {
            RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
            beanDefinition.setSource(source);
            beanDefinition.getPropertyValues().add("order", -2147483648);
            beanDefinition.setRole(2);
        // 注册自动代理创建器
            registry.registerBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator", beanDefinition);
            return beanDefinition;
        }
    }

获取优先级方法 `findPriorityForClass()` 方法通过维护的集合 `APC_PRIORITY_LIST` 索引值来确定优先级，索引值越小优先级越高。

// AopConfigUtils
    private static final List<Class<?>> APC_PRIORITY_LIST = new ArrayList<>();
    
    static {
       APC_PRIORITY_LIST.add(InfrastructureAdvisorAutoProxyCreator.class);
       APC_PRIORITY_LIST.add(AspectJAwareAdvisorAutoProxyCreator.class);
       APC_PRIORITY_LIST.add(AnnotationAwareAspectJAutoProxyCreator.class);
    }
    
    private static int findPriorityForClass(Class<?> clazz) {
       return APC_PRIORITY_LIST.indexOf(clazz);
    }
    
    private static int findPriorityForClass(@Nullable String className) {
       for (int i = 0; i < APC_PRIORITY_LIST.size(); i++) {
          Class<?> clazz = APC_PRIORITY_LIST.get(i);
          if (clazz.getName().equals(className)) {
             return i;
          }
       }
       throw new IllegalArgumentException(
             "Class name [" + className + "] is not a known auto-proxy creator class");
    }

注册完 `AnnotationAwareAspectJAutoProxyCreator` 之后，通过类继承图发现间接实现了 `BeanPostProcessor` ，而 `Spring` 会在 `bean` 初始化是调用 `postProcessAfterInitialization()` 方法，而改方法实现在其父类 `AbstractAutoProxyCreator` 中

![AnnotationAwareAspectJAutoProxyCreator继承结构][AnnotationAwareAspectJAutoProxyCreator]

// AbstractAutoProxyCreator
    public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) throws BeansException {
       if (bean != null) {
          Object cacheKey = getCacheKey(bean.getClass(), beanName);
          if (!this.earlyProxyReferences.contains(cacheKey)) {
             return wrapIfNecessary(bean, beanName, cacheKey);
          }
       }
       return bean;
    }

// AbstractAutoProxyCreator
    protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
       if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
          return bean;
       }
       //
       if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
          return bean;
       }
       // 如果是aop基础类或配置不需要代理 直接返回
       if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
          this.advisedBeans.put(cacheKey, Boolean.FALSE);
          return bean;
       }
    
       // 获取bean匹配的增强方法
       Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
       if (specificInterceptors != DO_NOT_PROXY) {
          this.advisedBeans.put(cacheKey, Boolean.TRUE);
          // 创建代理
          Object proxy = createProxy(
                bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
          this.proxyTypes.put(cacheKey, proxy.getClass());
          return proxy;
       }
    
       this.advisedBeans.put(cacheKey, Boolean.FALSE);
       return bean;
    }

// AbstractAdvisorAutoProxyCreator
    protected Object[] getAdvicesAndAdvisorsForBean(
          Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {
       // 查找合适的增强器
       List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
       if (advisors.isEmpty()) {
          return DO_NOT_PROXY;
       }
       return advisors.toArray();
    }

// AbstractAdvisorAutoProxyCreator
    protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
       // 寻找合适的增强器
       List<Advisor> candidateAdvisors = findCandidateAdvisors();
       // 确定增强器能否应用在bean上
       List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
       extendAdvisors(eligibleAdvisors);
       if (!eligibleAdvisors.isEmpty()) {
          eligibleAdvisors = sortAdvisors(eligibleAdvisors);
       }
       return eligibleAdvisors;
    }

// AnnotationAwareAspectJAutoProxyCreator
    protected List<Advisor> findCandidateAdvisors() {
       // 获取父类中其他aop配置
       List<Advisor> advisors = super.findCandidateAdvisors();
       // Build Advisors for all AspectJ aspects in the bean factory.
       if (this.aspectJAdvisorsBuilder != null) {
          // 获取注解方式aop配置
          advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
       }
       return advisors;
    }

// AbstractAdvisorAutoProxyCreator
    protected List<Advisor> findCandidateAdvisors() {
       Assert.state(this.advisorRetrievalHelper != null, "No BeanFactoryAdvisorRetrievalHelper available");
       // 获取配置为增强器的bean
       return this.advisorRetrievalHelper.findAdvisorBeans();
    }

// BeanFactoryAdvisorRetrievalHelper
    public List<Advisor> findAdvisorBeans() {
       // Determine list of advisor bean names, if not cached already.
       String[] advisorNames = null;
       synchronized (this) {
          advisorNames = this.cachedAdvisorBeanNames;
          if (advisorNames == null) {
             // Do not initialize FactoryBeans here: We need to leave all regular beans
             // uninitialized to let the auto-proxy creator apply to them!
             // 保持正常bean未初始化 而让自动代理创建器去处理
             advisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
                   this.beanFactory, Advisor.class, true, false);
             this.cachedAdvisorBeanNames = advisorNames;
          }
       }
       if (advisorNames.length == 0) {
          return new LinkedList<>();
       }
    
       List<Advisor> advisors = new LinkedList<>();
       for (String name : advisorNames) {
          if (isEligibleBean(name)) {
             if (this.beanFactory.isCurrentlyInCreation(name)) {
                if (logger.isDebugEnabled()) {
                   logger.debug("Skipping currently created advisor '" + name + "'");
                }
             }
             else {
                try {
                   // 添加至增强器列表
                   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)) {
                         if (logger.isDebugEnabled()) {
                            logger.debug("Skipping advisor '" + name +
                                  "' with dependency on currently created bean: " + ex.getMessage());
                         }
                         // Ignore: indicates a reference back to the bean we're trying to advise.
                         // We want to find advisors other than the currently created bean itself.
                         continue;
                      }
                   }
                   throw ex;
                }
             }
          }
       }
       return advisors;
    }

// BeanFactoryAspectJAdvisorsBuilder
    public List<Advisor> buildAspectJAdvisors() {
       List<String> aspectNames = this.aspectBeanNames;
    
       if (aspectNames == null) {
          synchronized (this) {
             aspectNames = this.aspectBeanNames;
             if (aspectNames == null) {
                List<Advisor> advisors = new LinkedList<>();
                aspectNames = new LinkedList<>();
                // 获取所有bean
                String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
                      this.beanFactory, Object.class, true, false);
                for (String beanName : beanNames) {
                   if (!isEligibleBean(beanName)) {
                      continue;
                   }
                   // We must be careful not to instantiate beans eagerly as in this case they
                   // would be cached by the Spring container but would not have been weaved.
                   // 获取对应的bean类型
                   Class<?> beanType = this.beanFactory.getType(beanName);
                   if (beanType == null) {
                      continue;
                   }
                   // 判断Bean是否添加@Aspect注解
                   if (this.advisorFactory.isAspect(beanType)) {
                      aspectNames.add(beanName);
                      AspectMetadata amd = new AspectMetadata(beanType, beanName);
                      if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
                         MetadataAwareAspectInstanceFactory factory =
                               new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
                         // 获取Aspect类所有方法的注解 
                         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 {
                         // Per target or per this.
                         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 LinkedList<>();
       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;
    }

// ReflectiveAspectJAdvisorFactory
    public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory) {
       Class<?> aspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
       String aspectName = aspectInstanceFactory.getAspectMetadata().getAspectName();
       validate(aspectClass);
    
       // We need to wrap the MetadataAwareAspectInstanceFactory with a decorator
       // so that it will only instantiate once.
       MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory =
             new LazySingletonAspectInstanceFactoryDecorator(aspectInstanceFactory);
    
       List<Advisor> advisors = new LinkedList<>();
       // 获取aspect类上所有增强方法(Pointcut注解排除)
       for (Method method : getAdvisorMethods(aspectClass)) {
          // 获取增强器
          Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, advisors.size(), aspectName);
          if (advisor != null) {
             advisors.add(advisor);
          }
       }
    
       // If it's a per target aspect, emit the dummy instantiating aspect.
       if (!advisors.isEmpty() && lazySingletonAspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {
          Advisor instantiationAdvisor = new SyntheticInstantiationAdvisor(lazySingletonAspectInstanceFactory);
          advisors.add(0, instantiationAdvisor);
       }
    
       // Find introduction fields.
       // 查找引介增强 并添加至集合
       for (Field field : aspectClass.getDeclaredFields()) {
          Advisor advisor = getDeclareParentsAdvisor(field);
          if (advisor != null) {
             advisors.add(advisor);
          }
       }
    
       return advisors;
    }

// ReflectiveAspectJAdvisorFactory
    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;
       }
    
       // 初始化增强器
       return new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod,
             this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
    }

// ReflectiveAspectJAdvisorFactory
    private AspectJExpressionPointcut getPointcut(Method candidateAdviceMethod, Class<?> candidateAspectClass) {
       // 获取方法上的注解(Before、Around、After、AfterReturning、AfterThrowing、Pointcut)
       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;
    }

下面开始看 `InstantiationModelAwarePointcutAdvisorImpl` 初始化流程

// InstantiationModelAwarePointcutAdvisorImpl
    public InstantiationModelAwarePointcutAdvisorImpl(AspectJExpressionPointcut declaredPointcut,
          Method aspectJAdviceMethod, AspectJAdvisorFactory aspectJAdvisorFactory,
          MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) {
    
       this.declaredPointcut = declaredPointcut;
       this.declaringClass = aspectJAdviceMethod.getDeclaringClass();
       this.methodName = aspectJAdviceMethod.getName();
       this.parameterTypes = aspectJAdviceMethod.getParameterTypes();
       this.aspectJAdviceMethod = aspectJAdviceMethod;
       this.aspectJAdvisorFactory = aspectJAdvisorFactory;
       this.aspectInstanceFactory = aspectInstanceFactory;
       this.declarationOrder = declarationOrder;
       this.aspectName = aspectName;
       // 判断是否设置延迟实例化
       if (aspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {
          // Static part of the pointcut is a lazy type.
          Pointcut preInstantiationPointcut = Pointcuts.union(
                aspectInstanceFactory.getAspectMetadata().getPerClausePointcut(), this.declaredPointcut);
    
          // Make it dynamic: must mutate from pre-instantiation to post-instantiation state.
          // If it's not a dynamic pointcut, it may be optimized out
          // by the Spring AOP infrastructure after the first evaluation.
          this.pointcut = new PerTargetInstantiationModelPointcut(
                this.declaredPointcut, preInstantiationPointcut, aspectInstanceFactory);
          this.lazy = true;
       }
       else {
          // A singleton aspect.
          this.pointcut = this.declaredPointcut;
          this.lazy = false;
          // 实例化增强器
          this.instantiatedAdvice = instantiateAdvice(this.declaredPointcut);
       }
    }

// InstantiationModelAwarePointcutAdvisorImpl
    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);
    }

// ReflectiveAspectJAdvisorFactory
    public Advice getAdvice(Method candidateAdviceMethod, AspectJExpressionPointcut expressionPointcut,
                      MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) {
    
       Class<?> candidateAspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
       validate(candidateAspectClass);
    
       AspectJAnnotation<?> aspectJAnnotation =
             AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
       if (aspectJAnnotation == null) {
          return null;
       }
    
       // If we get here, we know we have an AspectJ method.
       // Check that it's an AspectJ-annotated 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()) {
          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);
       }
    
       // Now to configure the advice...
       springAdvice.setAspectName(aspectName);
       springAdvice.setDeclarationOrder(declarationOrder);
       String[] argNames = this.parameterNameDiscoverer.getParameterNames(candidateAdviceMethod);
       if (argNames != null) {
          springAdvice.setArgumentNamesFromStringArray(argNames);
       }
       springAdvice.calculateArgumentBindings();
    
       return springAdvice;
    }

下面回到 `AbstractAdvisorAutoProxyCreator.findEligibleAdvisors()` 方法中，接着分析`findAdvisorsThatCanApply()` 方法，确定哪些增强器可以应用在 `bean` 上

// AbstractAdvisorAutoProxyCreator
    protected List<Advisor> findAdvisorsThatCanApply(
          List<Advisor> candidateAdvisors, Class<?> beanClass, String beanName) {
    
       ProxyCreationContext.setCurrentProxiedBeanName(beanName);
       try {
          // 获取当前bean可用的增强器
          return AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass);
       }
       finally {
          ProxyCreationContext.setCurrentProxiedBeanName(null);
       }
    }

// AopUtils
    public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz) {
       if (candidateAdvisors.isEmpty()) {
          return candidateAdvisors;
       }
       List<Advisor> eligibleAdvisors = new LinkedList<>();
       // 首先处理引介增强是否可以应用在当前bean上
       for (Advisor candidate : candidateAdvisors) {
          if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) {
             eligibleAdvisors.add(candidate);
          }
       }
       boolean hasIntroductions = !eligibleAdvisors.isEmpty();
       for (Advisor candidate : candidateAdvisors) {
          if (candidate instanceof IntroductionAdvisor) {
             // 引介增强已处理
             continue;
          }
          // 判断当前增强是否可以应用在当前bean上
          if (canApply(candidate, clazz, hasIntroductions)) {
             eligibleAdvisors.add(candidate);
          }
       }
       return eligibleAdvisors;
    }

`canApply` 的重载方法最终都会调用到下列的 `canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions)` 方法中

// AopUtils
    public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) {
       // 判断引介增强是否匹配
       if (advisor instanceof IntroductionAdvisor) {
          return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
       }
       else if (advisor instanceof PointcutAdvisor) {
          PointcutAdvisor pca = (PointcutAdvisor) advisor;
          // 判断是否可以应用在当前bean上
          return canApply(pca.getPointcut(), targetClass, hasIntroductions);
       }
       else {
          // It doesn't have a pointcut so we assume it applies.
          return true;
       }
    }

// AopUtils
    public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) {
       Assert.notNull(pc, "Pointcut must not be null");
       if (!pc.getClassFilter().matches(targetClass)) {
          return false;
       }
    
       // 获取方法匹配器
       MethodMatcher methodMatcher = pc.getMethodMatcher();
       if (methodMatcher == MethodMatcher.TRUE) {
          // No need to iterate the methods if we're matching any method anyway...
          return true;
       }
    
       IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;
       if (methodMatcher instanceof IntroductionAwareMethodMatcher) {
          introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher;
       }
    
       Set<Class<?>> classes = new LinkedHashSet<>();
       if (!Proxy.isProxyClass(targetClass)) {
          classes.add(ClassUtils.getUserClass(targetClass));
       }
       classes.addAll(ClassUtils.getAllInterfacesForClassAsSet(targetClass));
    
       for (Class<?> clazz : classes) {
          Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
          for (Method method : methods) {
             if (introductionAwareMethodMatcher != null ?
                   introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions) :
                   methodMatcher.matches(method, targetClass)) {
                return true;
             }
          }
       }
    
       return false;
    }

至此，这个配置解析流程完成。

# 参考资料 #

Spring源码深度解析  
[https://blog.csdn.net/heroqiang/article/details/79037741][https_blog.csdn.net_heroqiang_article_details_79037741]

[AnnotationAwareAspectJAutoProxyCreator]: /images/20220514/b77d1ab534b644fc91dd221983284f40.png
[https_blog.csdn.net_heroqiang_article_details_79037741]: https://blog.csdn.net/heroqiang/article/details/79037741