1 /**
 2      * Look for AspectJ-annotated aspect beans in the current bean factory,
 3      * and return to a list of Spring AOP Advisors representing them.
 4      * <p>Creates a Spring Advisor for each AspectJ advice method.
 5      * @return the list of {@link org.springframework.aop.Advisor} beans
 6      * @see #isEligibleBean
 7      */
 8     public List<Advisor> buildAspectJAdvisors() {
 9         List<String> aspectNames = this.aspectBeanNames;
10 
11         if (aspectNames == null) {
12             synchronized (this) {
13                 aspectNames = this.aspectBeanNames;
14                 if (aspectNames == null) {
15                     List<Advisor> advisors = new ArrayList<>();
16                     aspectNames = new ArrayList<>();
17                     String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
18                             this.beanFactory, Object.class, true, false);
19                     for (String beanName : beanNames) {
20                         if (!isEligibleBean(beanName)) {
21                             continue;
22                         }
23                         // We must be careful not to instantiate beans eagerly as in this case they
24                         // would be cached by the Spring container but would not have been weaved.
25                         Class<?> beanType = this.beanFactory.getType(beanName);
26                         if (beanType == null) {
27                             continue;
28                         }
29                         if (this.advisorFactory.isAspect(beanType)) {
30                             aspectNames.add(beanName);
31                             AspectMetadata amd = new AspectMetadata(beanType, beanName);
32                             if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
33                                 MetadataAwareAspectInstanceFactory factory =
34                                         new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
35                                 List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);
36                                 if (this.beanFactory.isSingleton(beanName)) {
37                                     this.advisorsCache.put(beanName, classAdvisors);
38                                 }
39                                 else {
40                                     this.aspectFactoryCache.put(beanName, factory);
41                                 }
42                                 advisors.addAll(classAdvisors);
43                             }
44                             else {
45                                 // Per target or per this.
46                                 if (this.beanFactory.isSingleton(beanName)) {
47                                     throw new IllegalArgumentException("Bean with name ‘" + beanName +
48                                             "‘ is a singleton, but aspect instantiation model is not singleton");
49                                 }
50                                 MetadataAwareAspectInstanceFactory factory =
51                                         new PrototypeAspectInstanceFactory(this.beanFactory, beanName);
52                                 this.aspectFactoryCache.put(beanName, factory);
53                                 advisors.addAll(this.advisorFactory.getAdvisors(factory));
54                             }
55                         }
56                     }
57                     this.aspectBeanNames = aspectNames;
58                     return advisors;
59                 }
60             }
61         }
62 
63         if (aspectNames.isEmpty()) {
64             return Collections.emptyList();
65         }
66         List<Advisor> advisors = new ArrayList<>();
67         for (String aspectName : aspectNames) {
68             List<Advisor> cachedAdvisors = this.advisorsCache.get(aspectName);
69             if (cachedAdvisors != null) {
70                 advisors.addAll(cachedAdvisors);
71             }
72             else {
73                 MetadataAwareAspectInstanceFactory factory = this.aspectFactoryCache.get(aspectName);
74                 advisors.addAll(this.advisorFactory.getAdvisors(factory));
75             }
76         }
77         return advisors;
78     }

1         for (Method method : getAdvisorMethods(aspectClass)) {
2             Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, advisors.size(), aspectName);
3             if (advisor != null) {
4                 advisors.add(advisor);
5             }
6         }

 1     private List<Method> getAdvisorMethods(Class<?> aspectClass) {
 2         final List<Method> methods = new ArrayList<>();
 3         ReflectionUtils.doWithMethods(aspectClass, method -> {
 4             // Exclude pointcuts
 5             if (AnnotationUtils.getAnnotation(method, Pointcut.class) == null) {
 6                 methods.add(method);
 7             }
 8         }, ReflectionUtils.USER_DECLARED_METHODS);
 9         methods.sort(METHOD_COMPARATOR);
10         return methods;
11     }

 1     @Override
 2     @Nullable
 3     public Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aspectInstanceFactory,
 4             int declarationOrderInAspect, String aspectName) {
 5 
 6         validate(aspectInstanceFactory.getAspectMetadata().getAspectClass());
 7 
 8         AspectJExpressionPointcut expressionPointcut = getPointcut(
 9                 candidateAdviceMethod, aspectInstanceFactory.getAspectMetadata().getAspectClass());
10         if (expressionPointcut == null) {
11             return null;
12         }
13 
14         return new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod,
15                 this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
16     }

 1     @Nullable
 2     private AspectJExpressionPointcut getPointcut(Method candidateAdviceMethod, Class<?> candidateAspectClass) {
 3         AspectJAnnotation<?> aspectJAnnotation =
 4                 AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
 5         if (aspectJAnnotation == null) {
 6             return null;
 7         }
 8 
 9         AspectJExpressionPointcut ajexp =
10                 new AspectJExpressionPointcut(candidateAspectClass, new String[0], new Class<?>[0]);
11         ajexp.setExpression(aspectJAnnotation.getPointcutExpression());
12         if (this.beanFactory != null) {
13             ajexp.setBeanFactory(this.beanFactory);
14         }
15         return ajexp;
16     }

 1     /**
 2      * Find and return the first AspectJ annotation on the given method
 3      * (there <i>should</i> only be one anyway...).
 4      */
 5     @SuppressWarnings("unchecked")
 6     @Nullable
 7     protected static AspectJAnnotation<?> findAspectJAnnotationOnMethod(Method method) {
 8         for (Class<?> clazz : ASPECTJ_ANNOTATION_CLASSES) {
 9             AspectJAnnotation<?> foundAnnotation = findAnnotation(method, (Class<Annotation>) clazz);
10             if (foundAnnotation != null) {
11                 return foundAnnotation;
12             }
13         }
14         return null;
15     }

1     private static final Class<?>[] ASPECTJ_ANNOTATION_CLASSES = new Class<?>[] {
2             Pointcut.class, Around.class, Before.class, After.class, AfterReturning.class, AfterThrowing.class};

 1     public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) {
 2         if (advisor instanceof IntroductionAdvisor) {
 3             return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
 4         }
 5         else if (advisor instanceof PointcutAdvisor) {
 6             PointcutAdvisor pca = (PointcutAdvisor) advisor;
 7             return canApply(pca.getPointcut(), targetClass, hasIntroductions);
 8         }
 9         else {
10             // It doesn‘t have a pointcut so we assume it applies.
11             return true;
12         }
13     }