spring——AOP原理及源码（二）
脑热 人气:0回顾：
在上一篇中，我们提到@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 }
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 }
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 }
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 }
一进来我们是停在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 }
invokeAwareMethods方法先判断是哪个类型的Aware接口，然后调用对应的set方法，所以它最终来到了我们的断点，setBeanFactory（）方法
接下来我们一路点击下一步，直到下图，这个BeanPostProcessor就创建完了，并通过orderedPostProcessors.add(pp)先添加到orderedPostProcessors中
再通过registerBeanPostProcessors(beanFactory, orderedPostProcessors)添加到beanFactory中
总结
以上整个过程，是创建完AnnotationAwareAspectJAutoProxyCreator后置处理器bean并存入beanFactory的过程。
下一篇将来探寻AnnotationAwareAspectJAutoProxyCreator在作为后置处理器存入bean工程之后的事。
今天是悲伤，再见了爱人，
加载全部内容