首页 > > 程序设计 > Java技术 >

spring——AOP原理及源码（二）

2020-03-03 16:05:09来源：博客园阅读 ()

spring——AOP原理及源码（二）

接下来我们就从后置处理器和BeanFactoryAware的角度来看看AnnotationAwareAspectJAutoProxyCreator的Bean定义类创建完成后都做了什么。

回顾：

在上一篇中，我们提到@EnableAspectJAutoProxy注解给容器中加入了一个关键组件internalAutoProxyCreator的BeanDefinition，实际类型为

AnnotationAwareAspectJAutoProxyCreator的BeanDenation

并且发现这是一个后置处理器，也是一个XXXAware接口的实现类。以及探究了它的继承关系如下。

接下来我们就从后置处理器和BeanFactoryAware的角度来看看AnnotationAwareAspectJAutoProxyCreator的BeanDefinition创建完成后都做了什么。

一、设置调试断点

我们分别进入四个有关类，在类中与后置处理器和BeanFactoryAware有关的方法上打上断点。最终效果如下：

AbstractAutoProxyCreator.setBeanFactory
AbstractAutoProxyCreator有后置处理器逻辑
{
　　postProcessBeforeInstantiation()
　　postProcessAfterInitialization()

AbstractAdvisorAutoProxyCreator.initBeanFactory
AbstractAdvisorAutoProxyCreator.setBeanFactory
AnnotationAwareAspectJAutoProxyCreator.initBeanFactory

最后，在配置类中给两个bean方法打上断点。

二、调试过程

开始调试，我们会发现还是先来到上一篇的AnnotationAwareAspectJAutoProxyCreator的BeanDenation创建过程。

左下角frames框中选到refresh方法可以看到，AnnotationAwareAspectJAutoProxyCreator的BeanDenation的创建是invokeBeanFactoryPostProcessors()方法调用来的。

调用这个方法在上下文中生成后置处理器的BeanDefinition加入容器中。

下一步的registerBeanPostProcessors才是注册后置处理器（利用BeanDefinition的信息注册对应Bean），也是本篇的重点。

为了让它快速创建完BeanDefinition，这里我们直接快进到下一个断点。

程序先来到了AbstractAdvisorAutoProxyCreator的setBeanFactory方法

为了从头看起，还是先在frames框中选到refresh方法，可以看到来到了refresh的下一方法，将要开始注册后置处理器。

二点一、registerBeanPostProcessors()

我们继续在frames中往上点，直到来到PostProcessorRegistrationDelegate.registerBeanPostProcessors()

方法有点长，但关键只在其中几个地方，我们将在下面进行针对分析

 1 public static void registerBeanPostProcessors(
 2             ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
 3 
 4         String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
 5 
 6         // Register BeanPostProcessorChecker that logs an info message when
 7         // a bean is created during BeanPostProcessor instantiation, i.e. when
 8         // a bean is not eligible for getting processed by all BeanPostProcessors.
 9         int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
10         beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
11 
12         // Separate between BeanPostProcessors that implement PriorityOrdered,
13         // Ordered, and the rest.
14         List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
15         List<BeanPostProcessor> internalPostProcessors = new ArrayList<BeanPostProcessor>();
16         List<String> orderedPostProcessorNames = new ArrayList<String>();
17         List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
18         for (String ppName : postProcessorNames) {
19             if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
20                 BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
21                 priorityOrderedPostProcessors.add(pp);
22                 if (pp instanceof MergedBeanDefinitionPostProcessor) {
23                     internalPostProcessors.add(pp);
24                 }
25             }
26             else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
27                 orderedPostProcessorNames.add(ppName);
28             }
29             else {
30                 nonOrderedPostProcessorNames.add(ppName);
31             }
32         }
33 
34         // First, register the BeanPostProcessors that implement PriorityOrdered.
35         sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
36         registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
37 
38         // Next, register the BeanPostProcessors that implement Ordered.
39         List<BeanPostProcessor> orderedPostProcessors = new ArrayList<BeanPostProcessor>();
40         for (String ppName : orderedPostProcessorNames) {
41             BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
42             orderedPostProcessors.add(pp);
43             if (pp instanceof MergedBeanDefinitionPostProcessor) {
44                 internalPostProcessors.add(pp);
45             }
46         }
47         sortPostProcessors(orderedPostProcessors, beanFactory);
48         registerBeanPostProcessors(beanFactory, orderedPostProcessors);
49 
50         // Now, register all regular BeanPostProcessors.
51         List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
52         for (String ppName : nonOrderedPostProcessorNames) {
53             BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
54             nonOrderedPostProcessors.add(pp);
55             if (pp instanceof MergedBeanDefinitionPostProcessor) {
56                 internalPostProcessors.add(pp);
57             }
58         }
59         registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
60 
61         // Finally, re-register all internal BeanPostProcessors.
62         sortPostProcessors(internalPostProcessors, beanFactory);
63         registerBeanPostProcessors(beanFactory, internalPostProcessors);
64 
65         // Re-register post-processor for detecting inner beans as ApplicationListeners,
66         // moving it to the end of the processor chain (for picking up proxies etc).
67         beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
68     }

registerBeanPostProcessors

4：获取所有后置处理器的名字

14~32：对实现不同接口的后置处理器进行分类

35~48：对上面的分类分别进行处理，因为实现的是Ordered接口，我们只关注39~48行

40~46：遍历分好的实现了Ordered接口的后置处理器名，利用beanFactory.getBean(ppName, BeanPostProcessor.class)来获取

二点二、doGetBean()

有了以上的步骤，我们主要来看beanFactory是怎么获取的

可以看到，先来到了getBean方法，然后又进入了doGetBean方法。下面我们来看doGetBean做了什么。

  1 /**
  2      * Return an instance, which may be shared or independent, of the specified bean.
  3      * @param name the name of the bean to retrieve
  4      * @param requiredType the required type of the bean to retrieve
  5      * @param args arguments to use when creating a bean instance using explicit arguments
  6      * (only applied when creating a new instance as opposed to retrieving an existing one)
  7      * @param typeCheckOnly whether the instance is obtained for a type check,
  8      * not for actual use
  9      * @return an instance of the bean
 10      * @throws BeansException if the bean could not be created
 11      */
 12     @SuppressWarnings("unchecked")
 13     protected <T> T doGetBean(
 14             final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
 15             throws BeansException {
 16 
 17         final String beanName = transformedBeanName(name);
 18         Object bean;
 19 
 20         // Eagerly check singleton cache for manually registered singletons.
 21         Object sharedInstance = getSingleton(beanName);
 22         if (sharedInstance != null && args == null) {
 23             if (logger.isDebugEnabled()) {
 24                 if (isSingletonCurrentlyInCreation(beanName)) {
 25                     logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
 26                             "' that is not fully initialized yet - a consequence of a circular reference");
 27                 }
 28                 else {
 29                     logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
 30                 }
 31             }
 32             bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
 33         }
 34 
 35         else {
 36             // Fail if we're already creating this bean instance:
 37             // We're assumably within a circular reference.
 38             if (isPrototypeCurrentlyInCreation(beanName)) {
 39                 throw new BeanCurrentlyInCreationException(beanName);
 40             }
 41 
 42             // Check if bean definition exists in this factory.
 43             BeanFactory parentBeanFactory = getParentBeanFactory();
 44             if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
 45                 // Not found -> check parent.
 46                 String nameToLookup = originalBeanName(name);
 47                 if (args != null) {
 48                     // Delegation to parent with explicit args.
 49                     return (T) parentBeanFactory.getBean(nameToLookup, args);
 50                 }
 51                 else {
 52                     // No args -> delegate to standard getBean method.
 53                     return parentBeanFactory.getBean(nameToLookup, requiredType);
 54                 }
 55             }
 56 
 57             if (!typeCheckOnly) {
 58                 markBeanAsCreated(beanName);
 59             }
 60 
 61             try {
 62                 final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
 63                 checkMergedBeanDefinition(mbd, beanName, args);
 64 
 65                 // Guarantee initialization of beans that the current bean depends on.
 66                 String[] dependsOn = mbd.getDependsOn();
 67                 if (dependsOn != null) {
 68                     for (String dep : dependsOn) {
 69                         if (isDependent(beanName, dep)) {
 70                             throw new BeanCreationException(mbd.getResourceDescription(), beanName,
 71                                     "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
 72                         }
 73                         registerDependentBean(dep, beanName);
 74                         getBean(dep);
 75                     }
 76                 }
 77 
 78                 // Create bean instance.
 79                 if (mbd.isSingleton()) {
 80                     sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
 81                         @Override
 82                         public Object getObject() throws BeansException {
 83                             try {
 84                                 return createBean(beanName, mbd, args);
 85                             }
 86                             catch (BeansException ex) {
 87                                 // Explicitly remove instance from singleton cache: It might have been put there
 88                                 // eagerly by the creation process, to allow for circular reference resolution.
 89                                 // Also remove any beans that received a temporary reference to the bean.
 90                                 destroySingleton(beanName);
 91                                 throw ex;
 92                             }
 93                         }
 94                     });
 95                     bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
 96                 }
 97 
 98                 else if (mbd.isPrototype()) {
 99                     // It's a prototype -> create a new instance.
100                     Object prototypeInstance = null;
101                     try {
102                         beforePrototypeCreation(beanName);
103                         prototypeInstance = createBean(beanName, mbd, args);
104                     }
105                     finally {
106                         afterPrototypeCreation(beanName);
107                     }
108                     bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
109                 }
110 
111                 else {
112                     String scopeName = mbd.getScope();
113                     final Scope scope = this.scopes.get(scopeName);
114                     if (scope == null) {
115                         throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
116                     }
117                     try {
118                         Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
119                             @Override
120                             public Object getObject() throws BeansException {
121                                 beforePrototypeCreation(beanName);
122                                 try {
123                                     return createBean(beanName, mbd, args);
124                                 }
125                                 finally {
126                                     afterPrototypeCreation(beanName);
127                                 }
128                             }
129                         });
130                         bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
131                     }
132                     catch (IllegalStateException ex) {
133                         throw new BeanCreationException(beanName,
134                                 "Scope '" + scopeName + "' is not active for the current thread; consider " +
135                                 "defining a scoped proxy for this bean if you intend to refer to it from a singleton",
136                                 ex);
137                     }
138                 }
139             }
140             catch (BeansException ex) {
141                 cleanupAfterBeanCreationFailure(beanName);
142                 throw ex;
143             }
144         }
145 
146         // Check if required type matches the type of the actual bean instance.
147         if (requiredType != null && bean != null && !requiredType.isInstance(bean)) {
148             try {
149                 return getTypeConverter().convertIfNecessary(bean, requiredType);
150             }
151             catch (TypeMismatchException ex) {
152                 if (logger.isDebugEnabled()) {
153                     logger.debug("Failed to convert bean '" + name + "' to required type '" +
154                             ClassUtils.getQualifiedName(requiredType) + "'", ex);
155                 }
156                 throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
157             }
158         }
159         return (T) bean;
160     }

AbstractBeanFactory.doGetBean

17：获取后置处理器的名称（这里也就是internalAutoProxyCreator）

21：根据bean名字获取对应单例

22~33：如果获取到的bean不为空，进行一系列操作（这里的internalAutoProxyCreator是第一次获取，bean应该是空，所以我们跳过22~33）

61：getMergedLocalBeanDefinition() 根据传入的后置处理器名称，获取其所有信息，在这里也就是从internalAutoProxyCreator的BeanDefinition中获取必要信息，这是为创建bean做准备。

79：判断如果是单例，调用getSingleton（）来获取

这里我们先不急着进入getSingleton（）方法，接着往下看先。

130：bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd) 将79行获取的scopedInstance包装为bean

159：返回bean

ok，getSingleton（）的获取是要返回的，所以这步是关键，接下来我们来看看getSingleton（）。

一直往上走，最终我们来到doCreateBean（），说明获取不到，接下来需要创建bean了

二点三、doCreateBean（）

  1 /**
  2      * Actually create the specified bean. Pre-creation processing has already happened
  3      * at this point, e.g. checking {@code postProcessBeforeInstantiation} callbacks.
  4      * <p>Differentiates between default bean instantiation, use of a
  5      * factory method, and autowiring a constructor.
  6      * @param beanName the name of the bean
  7      * @param mbd the merged bean definition for the bean
  8      * @param args explicit arguments to use for constructor or factory method invocation
  9      * @return a new instance of the bean
 10      * @throws BeanCreationException if the bean could not be created
 11      * @see #instantiateBean
 12      * @see #instantiateUsingFactoryMethod
 13      * @see #autowireConstructor
 14      */
 15     protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
 16             throws BeanCreationException {
 17 
 18         // Instantiate the bean.
 19         BeanWrapper instanceWrapper = null;
 20         if (mbd.isSingleton()) {
 21             instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
 22         }
 23         if (instanceWrapper == null) {
 24             instanceWrapper = createBeanInstance(beanName, mbd, args);
 25         }
 26         final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
 27         Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
 28         mbd.resolvedTargetType = beanType;
 29 
 30         // Allow post-processors to modify the merged bean definition.
 31         synchronized (mbd.postProcessingLock) {
 32             if (!mbd.postProcessed) {
 33                 try {
 34                     applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
 35                 }
 36                 catch (Throwable ex) {
 37                     throw new BeanCreationException(mbd.getResourceDescription(), beanName,
 38                             "Post-processing of merged bean definition failed", ex);
 39                 }
 40                 mbd.postProcessed = true;
 41             }
 42         }
 43 
 44         // Eagerly cache singletons to be able to resolve circular references
 45         // even when triggered by lifecycle interfaces like BeanFactoryAware.
 46         boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
 47                 isSingletonCurrentlyInCreation(beanName));
 48         if (earlySingletonExposure) {
 49             if (logger.isDebugEnabled()) {
 50                 logger.debug("Eagerly caching bean '" + beanName +
 51                         "' to allow for resolving potential circular references");
 52             }
 53             addSingletonFactory(beanName, new ObjectFactory<Object>() {
 54                 @Override
 55                 public Object getObject() throws BeansException {
 56                     return getEarlyBeanReference(beanName, mbd, bean);
 57                 }
 58             });
 59         }
 60 
 61         // Initialize the bean instance.
 62         Object exposedObject = bean;
 63         try {
 64             populateBean(beanName, mbd, instanceWrapper);
 65             if (exposedObject != null) {
 66                 exposedObject = initializeBean(beanName, exposedObject, mbd);
 67             }
 68         }
 69         catch (Throwable ex) {
 70             if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
 71                 throw (BeanCreationException) ex;
 72             }
 73             else {
 74                 throw new BeanCreationException(
 75                         mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
 76             }
 77         }
 78 
 79         if (earlySingletonExposure) {
 80             Object earlySingletonReference = getSingleton(beanName, false);
 81             if (earlySingletonReference != null) {
 82                 if (exposedObject == bean) {
 83                     exposedObject = earlySingletonReference;
 84                 }
 85                 else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
 86                     String[] dependentBeans = getDependentBeans(beanName);
 87                     Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);
 88                     for (String dependentBean : dependentBeans) {
 89                         if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
 90                             actualDependentBeans.add(dependentBean);
 91                         }
 92                     }
 93                     if (!actualDependentBeans.isEmpty()) {
 94                         throw new BeanCurrentlyInCreationException(beanName,
 95                                 "Bean with name '" + beanName + "' has been injected into other beans [" +
 96                                 StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
 97                                 "] in its raw version as part of a circular reference, but has eventually been " +
 98                                 "wrapped. This means that said other beans do not use the final version of the " +
 99                                 "bean. This is often the result of over-eager type matching - consider using " +
100                                 "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
101                     }
102                 }
103             }
104         }
105 
106         // Register bean as disposable.
107         try {
108             registerDisposableBeanIfNecessary(beanName, bean, mbd);
109         }
110         catch (BeanDefinitionValidationException ex) {
111             throw new BeanCreationException(
112                     mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
113         }
114 
115         return exposedObject;
116     }

AbstractAutowireCapableBeanFactory.doCreateBean

26：创建bean

64：populateBean(beanName, mbd, instanceWrapper) 给bean的属性赋值

66：initializeBean(beanName, exposedObject, mbd)初始化bean

下面我们来看这个初始化bean都做了什么

二点四、initializeBean（）

 1 /**
 2      * Initialize the given bean instance, applying factory callbacks
 3      * as well as init methods and bean post processors.
 4      * <p>Called from {@link #createBean} for traditionally defined beans,
 5      * and from {@link #initializeBean} for existing bean instances.
 6      * @param beanName the bean name in the factory (for debugging purposes)
 7      * @param bean the new bean instance we may need to initialize
 8      * @param mbd the bean definition that the bean was created with
 9      * (can also be {@code null}, if given an existing bean instance)
10      * @return the initialized bean instance (potentially wrapped)
11      * @see BeanNameAware
12      * @see BeanClassLoaderAware
13      * @see BeanFactoryAware
14      * @see #applyBeanPostProcessorsBeforeInitialization
15      * @see #invokeInitMethods
16      * @see #applyBeanPostProcessorsAfterInitialization
17      */
18     protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
19         if (System.getSecurityManager() != null) {
20             AccessController.doPrivileged(new PrivilegedAction<Object>() {
21                 @Override
22                 public Object run() {
23                     invokeAwareMethods(beanName, bean);
24                     return null;
25                 }
26             }, getAccessControlContext());
27         }
28         else {
29             invokeAwareMethods(beanName, bean);
30         }
31 
32         Object wrappedBean = bean;
33         if (mbd == null || !mbd.isSynthetic()) {
34             wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
35         }
36 
37         try {
38             invokeInitMethods(beanName, wrappedBean, mbd);
39         }
40         catch (Throwable ex) {
41             throw new BeanCreationException(
42                     (mbd != null ? mbd.getResourceDescription() : null),
43                     beanName, "Invocation of init method failed", ex);
44         }
45 
46         if (mbd == null || !mbd.isSynthetic()) {
47             wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
48         }
49         return wrappedBean;
50     }

AbstractAutowireCapableBeanFactory.initializeBean

一进来我们是停在29行的invokeAwareMethods(beanName, bean)，这里先不看它

我们来关注一下initializeBean的几个重要流程

1、invokeAwareMethods

2、34行applyBeanPostProcessorsBeforeInitialization

3、38行invokeInitMethods

4、47行applyBeanPostProcessorsAfterInitialization

先执行invokeAwareMethods，调用那些XXXAware方法，然后执行后置处理器的applyBeanPostProcessorsBeforeInitialization方法，接着执行初始化方法，最后执行后置处理器的applyBeanPostProcessorsAfterInitialization方法，这也是我们的后置处理器为什么能在bean初始化前后调用方法的原因了。

现在我们往下进入invokeAwareMethods

 1 private void invokeAwareMethods(final String beanName, final Object bean) {
 2         if (bean instanceof Aware) {
 3             if (bean instanceof BeanNameAware) {
 4                 ((BeanNameAware) bean).setBeanName(beanName);
 5             }
 6             if (bean instanceof BeanClassLoaderAware) {
 7                 ((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());
 8             }
 9             if (bean instanceof BeanFactoryAware) {
10                 ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
11             }
12         }
13     }