1
@Override
2
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
3
    Object cacheKey = getCacheKey(beanClass, beanName);
4

5
    if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
6
       if (this.advisedBeans.containsKey(cacheKey)) {
7
          return null;
8
       }
9
       if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {         // 缓存不需要创建动态代理的 Bean
10
          this.advisedBeans.put(cacheKey, Boolean.FALSE);
11
          return null;
12
       }
13
    }
14

15
    // Create proxy here if we have a custom TargetSource.
16
    // Suppresses unnecessary default instantiation of the target bean:    // The TargetSource will handle target instances in a custom fashion.    TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
17
    if (targetSource != null) {
18
       if (StringUtils.hasLength(beanName)) {
19
          this.targetSourcedBeans.add(beanName);
20
       }
21
       Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
22
       Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
23
       this.proxyTypes.put(cacheKey, proxy.getClass());
24
       return proxy;
25
    }
26

27
    return null;
28
}
29

30
@Override
31
protected boolean shouldSkip(Class<?> beanClass, String beanName) {
32
    // TODO: Consider optimization by caching the list of the aspect names
33
    List<Advisor> candidateAdvisors = findCandidateAdvisors();
34
    for (Advisor advisor : candidateAdvisors) {
35
       if (advisor instanceof AspectJPointcutAdvisor &&
36
             ((AspectJPointcutAdvisor) advisor).getAspectName().equals(beanName)) {
37
          return true;
38
       }
39
    }
40
    return super.shouldSkip(beanClass, beanName);
41
}
42

43
protected List<Advisor> findCandidateAdvisors() {
44
   Assert.state(this.advisorRetrievalHelper != null, "No BeanFactoryAdvisorRetrievalHelper available");
45
   return this.advisorRetrievalHelper.findAdvisorBeans();
46
}
47

48
public List<Advisor> findAdvisorBeans() {
49
    // Determine list of advisor bean names, if not cached already.
50
    String[] advisorNames = this.cachedAdvisorBeanNames;
51
    if (advisorNames == null) {
52
       // Do not initialize FactoryBeans here: We need to leave all regular beans
53
       // uninitialized to let the auto-proxy creator apply to them!       advisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
54
             this.beanFactory, Advisor.class, true, false);
55
       // 缓存 Advisor，避免重复扫描
56
       this.cachedAdvisorBeanNames = advisorNames;
57
    }
58
    if (advisorNames.length == 0) {
59
       return new ArrayList<>();
60
    }
61

62
    List<Advisor> advisors = new ArrayList<>();
63
    for (String name : advisorNames) {
64
       if (isEligibleBean(name)) {
65
          if (this.beanFactory.isCurrentlyInCreation(name)) {
66
             if (logger.isTraceEnabled()) {
67
                logger.trace("Skipping currently created advisor '" + name + "'");
68
             }
69
          }
70
          else {
71
             try {
72
                advisors.add(this.beanFactory.getBean(name, Advisor.class));
73
             }
74
             catch (BeanCreationException ex) {
75
                Throwable rootCause = ex.getMostSpecificCause();
76
                if (rootCause instanceof BeanCurrentlyInCreationException) {
77
                   BeanCreationException bce = (BeanCreationException) rootCause;
78
                   String bceBeanName = bce.getBeanName();
79
                   if (bceBeanName != null && this.beanFactory.isCurrentlyInCreation(bceBeanName)) {
80
                      if (logger.isTraceEnabled()) {
81
                         logger.trace("Skipping advisor '" + name +
82
                               "' with dependency on currently created bean: " + ex.getMessage());
83
                      }
84
                      // Ignore: indicates a reference back to the bean we're trying to advise.
85
                      // We want to find advisors other than the currently created bean itself.                      continue;
86
                   }
87
                }
88
                throw ex;
89
             }
90
          }
91
       }
92
    }
93
    return advisors;
94
}

1
@Override
2
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
3
    if (bean != null) {
4
       Object cacheKey = getCacheKey(bean.getClass(), beanName);
5
       if (this.earlyProxyReferences.remove(cacheKey) != bean) {
6
          return wrapIfNecessary(bean, beanName, cacheKey);
7
       }
8
    }
9
    return bean;
10
}
11

12
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
13
    if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
14
       return bean;
15
    }
16
    if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
17
       return bean;
18
    }
19
    if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
20
       this.advisedBeans.put(cacheKey, Boolean.FALSE);
21
       return bean;
22
    }
23

24
    // Create proxy if we have advice.
25
    Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
26
    if (specificInterceptors != DO_NOT_PROXY) {
27
       this.advisedBeans.put(cacheKey, Boolean.TRUE);
28
       Object proxy = createProxy(
29
             bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
30
       this.proxyTypes.put(cacheKey, proxy.getClass());
31
       return proxy;
32
    }
33

34
    this.advisedBeans.put(cacheKey, Boolean.FALSE);
35
    return bean;
36
}
37

38
protected Object[] getAdvicesAndAdvisorsForBean(
39
       Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {
40

41
    List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
42
    if (advisors.isEmpty()) {
43
       return DO_NOT_PROXY;
44
    }
45
    return advisors.toArray();
46
}
47

48
protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
49
  // 获取所有 Advisor 切面（@Before等注解）
50
    List<Advisor> candidateAdvisors = findCandidateAdvisors();
51
    // 筛选出当前 Bean 符合切面条件的 Advisor
52
    List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
53
    // advisors 里包含需要 MethodInvocation 的 Advice，会添加 ExposeInvocationInterceptor（添加到 advisors 列表的最前面）
54
    extendAdvisors(eligibleAdvisors);
55
    if (!eligibleAdvisors.isEmpty()) {
56
       eligibleAdvisors = sortAdvisors(eligibleAdvisors);
57
    }
58
    return eligibleAdvisors;
59
}

1
protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
2
       @Nullable Object[] specificInterceptors, TargetSource targetSource) {
3

4
    // ...
5

6
    ProxyFactory proxyFactory = new ProxyFactory();
7

8
    // ...
9

10
    // 这里把 advisors 添加到 proxyFactory 中
11
    Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
12
    proxyFactory.addAdvisors(advisors);
13
    // 这里会使用原来的 ClassLoader
14
    // Use original ClassLoader if bean class not locally loaded in overriding class loader
15
    ClassLoader classLoader = getProxyClassLoader();
16
    if (classLoader instanceof SmartClassLoader && classLoader != beanClass.getClassLoader()) {
17
       classLoader = ((SmartClassLoader) classLoader).getOriginalClassLoader();
18
    }
19
    // 通过代理工厂生成动态代理
20
    return proxyFactory.getProxy(classLoader);
21
}
22

23
public Object getProxy(@Nullable ClassLoader classLoader) {
24
    return createAopProxy().getProxy(classLoader);
25
}
26

27
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
28
    if (!NativeDetector.inNativeImage() &&
29
          (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config))) {
30
       Class<?> targetClass = config.getTargetClass();
31
       if (targetClass == null) {
32
          throw new AopConfigException("TargetSource cannot determine target class: " +
33
                "Either an interface or a target is required for proxy creation.");
34
       }
35
       if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
36
          return new JdkDynamicAopProxy(config);
37
       }
38
       return new ObjenesisCglibAopProxy(config);
39
    }
40
    else {
41
       return new JdkDynamicAopProxy(config);
42
    }
43
}

1
@Override
2
public Object getProxy(@Nullable ClassLoader classLoader) {
3
    //...
4

5
   // Configure CGLIB Enhancer...
6
   Enhancer enhancer = createEnhancer();
7
   if (classLoader != null) {
8
    enhancer.setClassLoader(classLoader);
9
    if (classLoader instanceof SmartClassLoader &&
10
      ((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) {
11
     enhancer.setUseCache(false);
12
    }
13
   }
14
   enhancer.setSuperclass(proxySuperClass);
15
   enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
16
   enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
17
   enhancer.setStrategy(new ClassLoaderAwareGeneratorStrategy(classLoader));
18

19
   Callback[] callbacks = getCallbacks(rootClass);
20
   Class<?>[] types = new Class<?>[callbacks.length];
21
   for (int x = 0; x < types.length; x++) {
22
    types[x] = callbacks[x].getClass();
23
   }
24
   // fixedInterceptorMap only populated at this point, after getCallbacks call above
25
   enhancer.setCallbackFilter(new ProxyCallbackFilter(
26
     this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset));
27
   enhancer.setCallbackTypes(types);
28

29
   // Generate the proxy class and create a proxy instance.
30
   return createProxyClassAndInstance(enhancer, callbacks);
31
}
32

33
private Callback[] getCallbacks(Class<?> rootClass) throws Exception {
34
    // Parameters used for optimization choices...
35

36
    // Choose an "aop" interceptor (used for AOP calls).
37
    Callback aopInterceptor = new DynamicAdvisedInterceptor(this.advised);
38

39
    //...
40

41
    Callback[] mainCallbacks = new Callback[] {
42
          aopInterceptor,  // for normal advice
43
          targetInterceptor,  // invoke target without considering advice, if optimized
44
          new SerializableNoOp(),  // no override for methods mapped to this
45
          targetDispatcher, this.advisedDispatcher,
46
          new EqualsInterceptor(this.advised),
47
          new HashCodeInterceptor(this.advised)
48
    };
49

50
    Callback[] callbacks;
51

52
    // If the target is a static one and the advice chain is frozen,
53
    // then we can make some optimizations by sending the AOP calls    // direct to the target using the fixed chain for that method.
54
    if (isStatic && isFrozen) {
55
       //...
56

57
       // Now copy both the callbacks from mainCallbacks
58
       // and fixedCallbacks into the callbacks array.       callbacks = new Callback[mainCallbacks.length + fixedCallbacks.length];
59
       System.arraycopy(mainCallbacks, 0, callbacks, 0, mainCallbacks.length);
60
       System.arraycopy(fixedCallbacks, 0, callbacks, mainCallbacks.length, fixedCallbacks.length);
61
       this.fixedInterceptorOffset = mainCallbacks.length;
62
    }
63
    else {
64
       callbacks = mainCallbacks;
65
    }
66
    return callbacks;
67
}

1
public Object getProxy(@Nullable ClassLoader classLoader) {
2
    if (logger.isTraceEnabled()) {
3
       logger.trace("Creating JDK dynamic proxy: " + this.advised.getTargetSource());
4
    }
5
    // this 是 JdkDynamicAopProxy
6
    return Proxy.newProxyInstance(classLoader, this.proxiedInterfaces, this);
7
}