老鱼进阶篇-Spring IOC容器初始化全流程源码解读分析

发表于

[TOC]

1、XML方式BeanDefination注册流程

1.1、测试demo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
java复制代码// 方法一，已过期
String path = "spring/beans.xml";
Resource resource = new ClassPathResource(path);
// BeanDefination注册流程
XmlBeanFactory beanFactory = new XmlBeanFactory(resource );

// 方法二
String path = "spring/beans.xml";
// 创建DefaultListableBeanFactory工厂，这也就是Spring的基本容器
DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
// 创建BeanDefinition阅读器
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);
// 进行BeanDefinition注册流程
reader.loadBeanDefinitions(path);

// 总结：两种方法最终都是通过XmlBeanDefinitionReader开启解析注册流程

// 方法三：通过高级容器进行创建
// 创建IoC容器，并进行初始化
ApplicationContext context = new ClassPathXmlApplicationContext("spring/spring-ioc.xml");
// 获取Bean的实例
Student bean = (Teacher) context.getBean(Teacher.class);

1.2、源码分析

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
java复制代码【XmlBeanFactory】#构造方法
	@@XmlBeanDefinitionReader
		# loadBeanDefinitions(EncodedResource resource)
		# doLoadBeanDefinitions(InputSource inputSource, Resource resource)
			// 通过DOM4J加载解析XML文件，最终形成Document对象
			#Document doc = doLoadDocument(inputSource, resource)
			// 通过对Document对象的操作，完成BeanDefinition的加载和注册工作
			# registerBeanDefinitions(doc, resource)
				// 创建BeanDefinitionDocumentReader来解析Document对象，完成BeanDefinition解析
				@@BeanDefinitionDocumentReader
					//解析过程入口，BeanDefinitionDocumentReader只是个接口
					# registerBeanDefinitions(doc, ..)
						// 具体的实现过程在DefaultBeanDefinitionDocumentReader完成
						@@DefaultBeanDefinitionDocumentReader
							// 真正实现BeanDefinition解析和注册工作
							# registerBeanDefinitions(doc, ..)
							// 委托给BeanDefinitionParserDelegate
							// 从Document的根元素开始进行BeanDefinition的解析
							# doRegisterBeanDefinitions(doc.getDocumentElement())
								# parseBeanDefinitions(Eleme(ele)nt root)
									// bean标签、import标签、alias标签，则使用默认解析规则
									# parseDefaultElement(Element ele)
										# processBeanDefinition(ele)
											@@BeanDefinitionParserDelegate
												# parseBeanDefinitionElement(ele)
													// 最终注册方法
													#BeanDefinitionReaderUtils			
														#registerBeanDefinition
									// 解析自定义标签，如：<aop:config>					
									#parseCustomElement()
										// 委托给BeanDefinitionParserDelegate
										@@BeanDefinitionParserDelegate
											# parseCustomElement(..)
                                                # BeanDefinitionParser(..)
                                                    #parse(Element element, ..)
                                                        ...省略
                                                        // 最终注册方法
                                                        #BeanDefinitionReaderUtils
                                                            #registerBeanDefinition	
    
【ClassPathXmlApplicationContext】#构造方法
    # setConfigLocations(configLocations)
    # refresh()
    	@@AbstractApplicationContext
    		# refresh()
    			public void refresh() {
                    synchronized (this.startupShutdownMonitor) {
                        // Prepare this context for refreshing.
                        // STEP 1： 刷新预处理
                        prepareRefresh();

                        // Tell the subclass to refresh the internal bean factory.
                        // STEP 2：
                        // 		a） 创建IoC容器（DefaultListableBeanFactory）
                        //		b） 加载解析XML文件（最终存储到Document对象中）
                        //		c） 读取Document对象，并完成BeanDefinition的加载和注册工作
                        ConfigurableListableBeanFactory beanFactory = 
                            	obtainFreshBeanFactory();

                        // Prepare the bean factory for use in this context.
                        // STEP 3： 对IoC容器进行一些预处理（设置一些公共属性）
                        prepareBeanFactory(beanFactory);

                        try {
                            // Allows post-processing of the bean factory 
                            // in context subclasses.
                            // STEP 4： 
                            postProcessBeanFactory(beanFactory);

                            // Invoke factory processors registered as beans
                            // in the context.
                            // STEP 5： 调用BeanFactoryPostProcessor后置处理器
                            // 对BeanDefinition处理
                            invokeBeanFactoryPostProcessors(beanFactory);

                            // Register bean processors that intercept bean creation.
                            // STEP 6： 注册BeanPostProcessor后置处理器
                            registerBeanPostProcessors(beanFactory);

                            // Initialize message source for this context.
                            // STEP 7： 初始化一些消息源（比如处理国际化的i18n等消息源）
                            initMessageSource();

                            // Initialize event multicaster for this context.
                            // STEP 8： 初始化应用事件广播器
                            initApplicationEventMulticaster();

                            // Initialize other special beans 
                            // in specific context subclasses.
                            // STEP 9： 初始化一些特殊的bean
                            onRefresh();

                            // Check for listener beans and register them.
                            // STEP 10： 注册一些监听器
                            registerListeners();

                            // Instantiate all remaining (non-lazy-init) singletons.
                            // STEP 11： 实例化剩余的单例bean（非懒加载方式）
                            // 注意事项：Bean的IoC、DI和AOP都是发生在此步骤
                            finishBeanFactoryInitialization(beanFactory);

                            // Last step: publish corresponding event.
                            // STEP 12： 完成刷新时，需要发布对应的事件
                            finishRefresh();
                        } catch (BeansException ex) {
                            // Destroy already created singletons
                            // to avoid dangling resources.
                            destroyBeans();

                            // Reset 'active' flag.
                            cancelRefresh(ex);
							...
                        } finally {
                           // Reset common introspection caches in Spring's core, since 
                           // might not ever need metadata for singleton beans anymore
                           resetCommonCaches();
                        }
                    }
                }
		// 通过此方法来解析相关BeanDefinition, 还会完成其余附属功能
		# obtainFreshBeanFactory()
            @@AbstractRefreshableApplicationContext
            	// 如果之前有IoC容器，则销毁
            	# refreshBeanFactory()
            		// 创建IoC容器，也就是DefaultListableBeanFactory
            		# createBeanFactory()
            		// 设置工厂的属性：是否允许BeanDefinition覆盖和是否允许循环依赖
					# customizeBeanFactory(beanFactory);
					// 调用载入BeanDefinition的方法，在当前类中只定义了抽象的
					// loadBeanDefinitions方法，具体的实现调用子类容器
					# loadBeanDefinitions(beanFactory); //钩子方法
						@@ AbstractXmlApplicationContext
							# loadBeanDefinitions(DefaultListableBeanFactory beanFactory)
                            	@@XmlBeanDefinitionReader
                            		// XML Bean读取器调用其父类
                            		// AbstractBeanDefinitionReader读取定位的资源
                            		@@ AbstractBeanDefinitionReader
										# loadBeanDefinitions(configLocations)
                            				...
                            				// 委派调用其子类
                            				// XmlBeanDefinitionReader的方法，实现加载功能
                            				# loadBeanDefinitions(Resource resource)
                            				// 至此，回到上面1或者2的流程处理

2、注解方式BeanDefination注册流程

2.1 测试代码

1
2
java复制代码AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext("com.spring.test.ioc.annotation.po");
Teacher student = context.getBean(Teacher.class);

2.2 源码分析

1
2
3
4
5
6
java复制代码【AnnotationConfigApplicationContext】#构造方法
	# scan(basePackages);
    # refresh();
		@@AbstractApplicationContext
    		# refresh() 
            // 解析源码见1.2说明

3、IOC容器启动核心流程（12步）

3.1 prepareRefresh刷新预处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
java复制代码protected void prepareRefresh() {
    // 1、这个方法设置context的启动日期。
    this.startupDate = System.currentTimeMillis();
    
    // 2、设置context当前的状态，是活动状态还是关闭状态。
    this.closed.set(false);
	this.active.set(true);
    
    // 3、初始化context environment（上下文环境）中的占位符属性来源。
    // 扩展覆盖protected void initPropertySources()方法，加载自定义环境属性值
    // 如：getEnvironment().getSystemProperties().put("name","bobo");
    initPropertySources();

    // 4、验证所有必需的属性。
    // 如：上一步getEnvironment().setRequiredProperties("username");
    // 则在当前方法会进行校验，不存在则抛出异常
    getEnvironment().validateRequiredProperties();

    // 5、创建一些监听器事件的集合
    this.earlyApplicationEvents = new LinkedHashSet<>();
}

3.2 obtainFreshBeanFactory创建默认工厂

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
java复制代码protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
    // 主要是通过该方法完成IoC容器的刷新
    refreshBeanFactory();
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    return beanFactory;
}

protected final void refreshBeanFactory() throws BeansException {
    // 1、如果之前有IoC容器，则销毁
    if (hasBeanFactory()) {
        // 销毁bean
        destroyBeans();
        // 关闭bean工厂
        closeBeanFactory();
    }
    // 2、创建IoC容器，也就是DefaultListableBeanFactory
    DefaultListableBeanFactory beanFactory = createBeanFactory();
    beanFactory.setSerializationId(getId());
    // 3、设置工厂的属性：是否允许BeanDefinition覆盖和是否允许循环依赖
    customizeBeanFactory(beanFactory);
    // 4、调用载入BeanDefinition的方法，在当前类中只定义了抽象的loadBeanDefinitions方法，
    // 具体的实现调用子类容器如：AnnotationConfigWebApplicationContext、			
    // AbstractXmlApplicationContext
    loadBeanDefinitions(beanFactory);
    synchronized (this.beanFactoryMonitor) {
        // 5、将创建好的bean工厂的引用交给的context来管理。
        this.beanFactory = beanFactory;
    }
}

3.3 prepareBeanFactory 配置预处理容器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
java复制代码// 配置这个工厂的标准环境，比如context的类加载器和后处理器
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		// 1、设置beanFactory的类加载器
		beanFactory.setBeanClassLoader(getClassLoader());
    	// 2、设置属性解析器
		beanFactory.setBeanExpressionResolver(new                                      					StandardBeanExpressionResolver(beanFactory.getBeanClassLoader())); 
		beanFactory.addPropertyEditorRegistrar(new 
                ResourceEditorRegistrar(this,getEnvironment()));

		// 3、添加到后置处理器列表, 新创建的 ApplicationContextAwareProcessor 
    	// 入参为当前 ApplicationContext, 为实现Aware接口的bean设置对应的对象
		beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
    	// 4、忽略自动属性装配/赋值，默认只有BeanFactoryAware被忽略，要忽略其他类型，需要单独设置
    	// 此处目的是为了交给用户自定义实现Aware功能，基于自定义后置处理器处理Bean依赖
    	// 忽略该接口的实现类中和接口setter方法入参类型相同的依赖。
    	// 这样的做法使得ApplicationContextAware和BeanFactoryAware中的ApplicationContext或			// BeanFactory依赖在自动装配时被忽略，而统一由框架设置依赖，如ApplicationContextAware接口			// 的设置会在ApplicationContextAwareProcessor类中完成.
		beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
		beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
		beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
		beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
		
		// 5、该方法的主要作用就是指定该类型接口，如果外部要注入该类型接口的对象，则会注入我们
    	// 指定的对象，而不会去管其他接口实现类（因为多个实现类不知道注入哪个，在这里明确指定）
		beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
		beanFactory.registerResolvableDependency(ResourceLoader.class, this);
		beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
		beanFactory.registerResolvableDependency(ApplicationContext.class, this);
		
    	// 6、用于处理实现ApplicationListener接口的bean,bean初始化后添加监听
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
    
    	// 7、增加对AspectJ的支持
		if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new                      
                      LoadTimeWeaverAwareProcessor(beanFactory));
			beanFactory.setTempClassLoader(new                                 			 
              ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}
		// 8、给容器中注册Singleton组件,ConfigurableEnviroment,systemProperties,
    	// systemEnvironment，添加到singletonObjects（ConcurrentHashMap类型）中
		if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
			beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
		}
		if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
			beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, 	
                                          getEnvironment().getSystemProperties());
		}
		if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
			beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, 
                                          getEnvironment().getSystemEnvironment());
		}
	}

3.4 postProcessBeanFactory 重写自定义修改bean工厂方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
java复制代码// 因为此方法的参数是BeanFactory，所以我们可以重写此方法，然后针对beanFactory进行一些修改。
@Override
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    // ServletContextAwareProcessor中拿到应用上下文持有的servletContext引用和servletConfig引用
    // 1.添加ServletContextAwareProcessor处理器
    beanFactory.addBeanPostProcessor(new 	
             ServletContextAwareProcessor(this.servletContext, this.servletConfig));    
    // 在自动注入时忽略指定的依赖接口，通常被应用上下文用来注册以其他方式解析的依赖项
    beanFactory.ignoreDependencyInterface(ServletContextAware.class);
    beanFactory.ignoreDependencyInterface(ServletConfigAware.class);

    // 2.注册web应用的scopes
    WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, 
                                        this.servletContext);
    
    // 3.注册和环境有关的beans
    WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext, 						this.servletConfig);
}

3.5 invokeBeanFactoryPostProcessors BeanFactory处理器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
java复制代码protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory 	
                                               	beanFactory) {
    // 1.getBeanFactoryPostProcessors(): 拿到当前应用上下文beanFactoryPostProcessors
    // 变量中的值，默认为空的，除非自己手动调用	context.addBeanFactoryPostProcessor
    // (beanFactoryPostProcessor)完成自定义添加
    // 2.invokeBeanFactoryPostProcessors: 实例化并调用所有已注册的BeanFactoryPostProcessor
	PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, 	
 							getBeanFactoryPostProcessors());

	if (beanFactory.getTempClassLoader() == null && 
        				beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
		beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
		beanFactory.setTempClassLoader(new 
					ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
	}
}

public static void invokeBeanFactoryPostProcessors(
        ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> 	
    								beanFactoryPostProcessors) {
    Set<String> processedBeans = new HashSet<String>();
    // 1. beanFactory为DefaultListableBeanFactory, DefaultListableBeanFactory实现了
    // BeanDefinitionRegistry接口，判定为true
    if (beanFactory instanceof BeanDefinitionRegistry) {
        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
        // 1.1 保存普通的BeanFactoryPostProcessor
        List<BeanFactoryPostProcessor> regularPostProcessors = new 
            								LinkedList<BeanFactoryPostProcessor>();
        // 1.2 保存BeanDefinitionRegistryPostProcessor
        List<BeanDefinitionRegistryPostProcessor> registryProcessors = new 
            					 LinkedList<BeanDefinitionRegistryPostProcessor>();
        // 2. 遍历入参中beanFactoryPostProcessors, 将BeanDefinitionRegistryPostProcessor
        // 和普通BeanFactoryPostProcessor区分开
        for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
            if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                // 2.1. 如果是BeanDefinitionRegistryPostProcessor
                BeanDefinitionRegistryPostProcessor registryProcessor =
                        (BeanDefinitionRegistryPostProcessor) postProcessor;
                // 2.2. 执行BeanDefinitionRegistryPostProcessor接口的		
                // postProcessBeanDefinitionRegistry方法
                registryProcessor.postProcessBeanDefinitionRegistry(registry);
                // 2.3. 添加到registryProcessors(用于最后执行postProcessBeanFactory方法)
                registryProcessors.add(registryProcessor);
            } else {
                // 3.1. 普通的BeanFactoryPostProcessor添加到regularPostProcessors
                // (用于最后执行postProcessBeanFactory方法)
                regularPostProcessors.add(postProcessor);
            }
        }
        
        // 保存本次要执行的所有BeanDefinitionRegistryPostProcessor
        List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new 	
            					ArrayList<BeanDefinitionRegistryPostProcessor>();
        
        // 4. 找出所有实现PriorityOrdered接口的BeanDefinitionRegistryPostProcessor实现类
        // 找出所有实现BeanDefinitionRegistryPostProcessor接口的Bean的beanName
        String[] postProcessorNames = beanFactory.getBeanNamesForType
            				(BeanDefinitionRegistryPostProcessor.class, true, false);
        
        // 5. 遍历postProcessorNames
        for (String ppName : postProcessorNames) {
            // 5.1. 判定是否实现了PriorityOrdered接口
            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                // 5.2. 获取ppName对应的bean实例, 添加到currentRegistryProcessors中,
                // beanFactory.getBean方法会触发创建ppName对应的bean实例
                currentRegistryProcessors.add(beanFactory.getBean(ppName, 
										BeanDefinitionRegistryPostProcessor.class));
                // 5.3. 将实现类名添加到processedBeans，防止重复
                processedBeans.add(ppName);
            }
        }
        // 6. 进行排序(根据是否实现PriorityOrdered、Ordered接口和order值来排序)
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        // 7. 添加到registryProcessors(用于最后执行postProcessBeanFactory方法)
        registryProcessors.addAll(currentRegistryProcessors);
        // 8. 遍历currentRegistryProcessors, 执行postProcessBeanDefinitionRegistry方法
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
        // 9. 清空currentRegistryProcessors
        currentRegistryProcessors.clear();
 
       	// 10. 找出所有实现BeanDefinitionRegistryPostProcessor接口的类, 
        // 重复查找是因为执行完上面的BeanDefinitionRegistryPostProcessor,
        // 可能会新增了其他的BeanDefinitionRegistryPostProcessor
        postProcessorNames = beanFactory.getBeanNamesForType
            				(BeanDefinitionRegistryPostProcessor.class, true, false);
        for (String ppName : postProcessorNames) {
            // 校验是否实现了Ordered接口，并且还未执行过
            if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, 
                                                 					Ordered.class)) {
                currentRegistryProcessors.add(beanFactory.getBean(ppName, 	
							BeanDefinitionRegistryPostProcessor.class));
                processedBeans.add(ppName);
            }
        }
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        registryProcessors.addAll(currentRegistryProcessors);
        // 11. 遍历currentRegistryProcessors, 执行postProcessBeanDefinitionRegistry方法
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
        currentRegistryProcessors.clear();
 
        // 12. 最后查找所有剩下的BeanDefinitionRegistryPostProcessors
        boolean reiterate = true;
        while (reiterate) {
            reiterate = false;
            // 12.1 找出所有实现BeanDefinitionRegistryPostProcessor接口的类
            postProcessorNames = beanFactory.getBeanNamesForType
               				 (BeanDefinitionRegistryPostProcessor.class, true, false);
            for (String ppName : postProcessorNames) {
                // 12.2 跳过已经执行过的
                if (!processedBeans.contains(ppName)) {
                    currentRegistryProcessors.add(beanFactory.getBean(ppName, 
 										BeanDefinitionRegistryPostProcessor.class));
                    processedBeans.add(ppName);
                    // 12.3 如果有BeanDefinitionRegistryPostProcessor被执行,
                    // 则有可能会产生新的BeanDefinitionRegistryPostProcessor,
                    // 因此这边将reiterate赋值为true, 代表需要再循环查找一次
                    reiterate = true;
                }
            }
            sortPostProcessors(currentRegistryProcessors, beanFactory);
            registryProcessors.addAll(currentRegistryProcessors);
            // 13. 遍历currentRegistryProcessors, 执行postProcessBeanDefinitionRegistry方法
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, 	
                                                       	registry);
            currentRegistryProcessors.clear();
        }
 
        // 14. 调用所有BeanDefinitionRegistryPostProcessor的postProcessBeanFactory方法	
        // (BeanDefinitionRegistryPostProcessor继承自BeanFactoryPostProcessor)
        invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
        // 15. 调用入参beanFactoryPostProcessors中的普通BeanFactoryPostProcessor的		
        // postProcessBeanFactory方法
        invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
    } else {
        // 直接调用传过来的BeanDefinitionRegistryPostProcessor的postProcessBeanFactory方法
        invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
    }
 
    // 到这里入参beanFactoryPostProcessors和容器中的所BeanDefinitionRegistryPostProcessor
    // 已经全部处理完毕,下面开始处理容器中的所有BeanFactoryPostProcessor
 
    // 16.找出所有实现BeanFactoryPostProcessor接口的类
    String[] postProcessorNames =
            beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
    // 17. 保存实现了PriorityOrdered接口的BeanFactoryPostProcessor
    List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new 
        										ArrayList<BeanFactoryPostProcessor>();
    // 保存实现了Ordered接口的BeanFactoryPostProcessor的beanName
    List<String> orderedPostProcessorNames = new ArrayList<String>();
    // 保存普通BeanFactoryPostProcessor的beanName
    List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
    // 18. 遍历postProcessorNames, 将BeanFactoryPostProcessor
    // 按实现PriorityOrdered、实现Ordered接口、普通三种区分开
    for (String ppName : postProcessorNames) {
        if (processedBeans.contains(ppName)) {
            // 18.1 跳过已经执行过的
        } else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            // 18.2 添加实现了PriorityOrdered接口的BeanFactoryPostProcessor
            priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, 	
												BeanFactoryPostProcessor.class));
        } else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            // 18.3 添加实现了Ordered接口的BeanFactoryPostProcessor的beanName
            orderedPostProcessorNames.add(ppName);
        } else {
            // 18.4 添加剩下的普通BeanFactoryPostProcessor的beanName
            nonOrderedPostProcessorNames.add(ppName);
        }
    }
 
    // 19. 对priorityOrderedPostProcessors排序
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    // 20. 调用所有实现PriorityOrdered接口的BeanFactoryPostProcessor
    // 遍历priorityOrderedPostProcessors, 执行postProcessBeanFactory方法
    invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
 
    // 21. 调用所有实现Ordered接口的BeanFactoryPostProcessor
    List<BeanFactoryPostProcessor> orderedPostProcessors = new 	
        									ArrayList<BeanFactoryPostProcessor>();
    for (String postProcessorName : orderedPostProcessorNames) {
        // 21.1 获取postProcessorName对应的bean实例, 添加到orderedPostProcessors, 准备执行
        orderedPostProcessors.add(beanFactory.getBean(postProcessorName, 
                                                 BeanFactoryPostProcessor.class));
    }
    // 21.2 对orderedPostProcessors排序
    sortPostProcessors(orderedPostProcessors, beanFactory);
    // 21.3 遍历orderedPostProcessors, 执行postProcessBeanFactory方法
    invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

    // 22.调用所有剩下的BeanFactoryPostProcessor
    List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new 
        									ArrayList<BeanFactoryPostProcessor>();
    for (String postProcessorName : nonOrderedPostProcessorNames) {
        // 22.1 获取postProcessorName对应的bean实例, 添加到nonOrderedPostProcessors
        nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, 
												BeanFactoryPostProcessor.class));
    }
    // 22.2 遍历nonOrderedPostProcessors, 执行postProcessBeanFactory方法
    invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
 
    // 23. 清除元数据缓存（mergedBeanDefinitions、allBeanNamesByType、	
    // singletonBeanNamesByType），
    // 因为后处理器可能已经修改了原始元数据，例如: 替换值中的占位符
    beanFactory.clearMetadataCache();
}

3.6 registerBeanPostProcessors 注册后置处理器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
java复制代码// 注册用来拦截bean创建的BeanPostProcessor bean.这个方法需要在所有的application bean初始化之前调、
// 用。把这个注册的任务委托给了PostProcessorRegistrationDelegate来完成。
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}

public static void registerBeanPostProcessors(ConfigurableListableBeanFactory 			
                            beanFactory,AbstractApplicationContext applicationContext) {
	// 1. 查找所有实现BeanPostProcessor的后置处理器名称	
    String[] postProcessorNames = beanFactory.getBeanNamesForType
        										(BeanPostProcessor.class, true, false);
		// 2. 计算处理器总数
		int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + 
            						postProcessorNames.length;
		beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, 
 									beanProcessorTargetCount));

		// 3. 对所有的BeanPostProcessor按照PriorityOrdered、Ordered和普通的进行分组存储
		List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
		List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
		List<String> orderedPostProcessorNames = new ArrayList<>();
		List<String> nonOrderedPostProcessorNames = new ArrayList<>();
		for (String ppName : postProcessorNames) {
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				BeanPostProcessor pp = beanFactory.getBean(ppName, 
                                                           BeanPostProcessor.class);
				priorityOrderedPostProcessors.add(pp);
				if (pp instanceof MergedBeanDefinitionPostProcessor) {
					internalPostProcessors.add(pp);
				}
			}
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

		// 4. 排序并注册所有实现了PriorityOrdered的后置处理器
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

		// 5. 排序并注册所有实现了Ordered的后置处理器
		List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
		for (String ppName : orderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			orderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		sortPostProcessors(orderedPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, orderedPostProcessors);

		// 6. 注册所有普通的后置处理器
		List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
		for (String ppName : nonOrderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			nonOrderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

		// 排序并注册所有实现了MergedBeanDefinitionPostProcessor的应用处理器
		sortPostProcessors(internalPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, internalPostProcessors);

		// 重新注册用来自动探测内部ApplicationListener的post-processor，
    	// 这样可以将他们移到处理器链条的末尾
		beanFactory.addBeanPostProcessor(new 		
                              ApplicationListenerDetector(applicationContext));
	}

3.7 initMessageSource 初始化消息源

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
java复制代码// 初始化MessageSource接口的一个实现类。这个接口提供了消息处理功能。主要用于国际化/i18n。
// 此部分代码不做详细阐述
protected void initMessageSource() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
        this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, 	
                                                 MessageSource.class);
        if (this.parent != null && this.messageSource 
            instanceof HierarchicalMessageSource) {
            HierarchicalMessageSource hms = (HierarchicalMessageSource) 
                this.messageSource;
            if (hms.getParentMessageSource() == null) {
                hms.setParentMessageSource(getInternalParentMessageSource());
            }
        }
    }
    else {
        DelegatingMessageSource dms = new DelegatingMessageSource();
        dms.setParentMessageSource(getInternalParentMessageSource());
        this.messageSource = dms;
        beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
    }
}

3.8 initApplicationEventMulticaster 初始化应用事件广播器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
java复制代码// 为context初始化一个事件监听多路广播器（ApplicationEventMulticaster）
protected void initApplicationEventMulticaster() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    // 检查是否给context配了一个ApplicationEventMulticaster实现类
    if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
        this.applicationEventMulticaster =
            beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, 
                                ApplicationEventMulticaster.class);
    }
    else {
        // 如果没有，就使用默认的实现类 SimpleApplicationEventMulticaster
        this.applicationEventMulticaster = new 	
            			SimpleApplicationEventMulticaster(beanFactory);
        beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, 
                                      this.applicationEventMulticaster);
    }
}

3.9 onRefresh初始化特殊的Bean

1
2
3
4
5
6
7
8
9
10
java复制代码// 在AbstractApplicationContext的子类中初始化其他特殊的bean。其实就是初始化ThemeSource接口的实例。
// 这个方法需要在所有单例bean初始化之前调用。
protected void onRefresh() throws BeansException {
    // 是个空壳方法，在AnnotationApplicationContex上下文中没有实现，
    // 可能在spring后面的版本会去扩展。
}
@Override
protected void onRefresh() {
    this.themeSource = UiApplicationContextUtils.initThemeSource(this);
}

3.10 registerListeners 注册应用监听器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
java复制代码// 注册应用的监听器。就是注册实现了ApplicationListener接口的监听器bean，这些监听器是注册到
// ApplicationEventMulticaster中的。这不会影响到其它监听器bean。在注册完以后，还会将其前期的事件发布
// 给相匹配的监听器。
protected void registerListeners() {
    // 获取实现了ApplicationListener的监听器
    for (ApplicationListener<?> listener : getApplicationListeners()) {
        // 手动注册的监听器绑定到广播器
        getApplicationEventMulticaster().addApplicationListener(listener);
    }

    // 取到监听器的名称
    String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, 
    // 设置到广播器                                                			false);
    for (String listenerBeanName : listenerBeanNames) {
        getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
    }

   	// 如果存在早期应用事件，发布事件消息
    Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
    this.earlyApplicationEvents = null;
    if (earlyEventsToProcess != null) {
        for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
            getApplicationEventMulticaster().multicastEvent(earlyEvent);
        }
    }
}

3.11 finishBeanFactoryInitialization 实例化非懒加载Bean

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
java复制代码// 完成bean工厂的初始化工作。这一步非常复杂，也非常重要，涉及到了bean的创建。第二步中只是完成了
// BeanDefinition的定义、解析、处理、注册。但是还没有初始化bean实例。这一步 实例化剩余的单例bean（非懒
// 加载方式）. 注意事项：Bean的IoC、DI和AOP都是发生在此步骤
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory 
                                               						beanFactory) {
		// 1. 初始化此上下文的转换服务
    	...
        // 2. 如果beanFactory之前没有注册嵌入值解析器，则注册默认的嵌入值解析器：
        // 主要用于注解属性值的解析。
        ...
		// 3. 初始化LoadTimeWeaverAware Bean实例对象
		String[] weaverAwareNames = beanFactory.getBeanNamesForType
            								(LoadTimeWeaverAware.class, false, false);
		for (String weaverAwareName : weaverAwareNames) {
			getBean(weaverAwareName);
		}

		// Stop using the temporary ClassLoader for type matching.
		beanFactory.setTempClassLoader(null);

		// 4. 冻结所有bean定义，注册的bean定义不会被修改
    	// 或进一步后处理，因为马上要创建 Bean 实例对象了
		beanFactory.freezeConfiguration();

		// 实例化单例Bean， 将在第四节【Bean初始化流程分析】进行讲解
		beanFactory.preInstantiateSingletons();
	}

3.12 finishRefresh 完成刷新发布应用事件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
java复制代码// 完成context的刷新。主要是调用LifecycleProcessor的onRefresh()方法，并且发布事件
//（ContextRefreshedEvent）。
protected void finishRefresh() {
    // Clear context-level resource caches (such as ASM metadata from scanning).
    clearResourceCaches();

    // 为此上下文初始化生命周期处理器
    // 初始化所有的 LifecycleProcessor
    // 在 Spring 中还提供了 Lifecycle 接口， Lifecycle 中包含 start/stop 方法，
    // 实现此接口后 Spring 会保证在启动的时候调用其 start 方法开始生命周期，
    // 并在 Spring 关闭的时候调用 stop 方法来结束生命周期，通常用来配置后台程序，在启动后一直运行
    // （如对 MQ 进行轮询等）。ApplicationContext 的初始化最后正是保证了这一功能的实现。
    initLifecycleProcessor();

    // 将刷新完成事件广播到生命周期处理器
    getLifecycleProcessor().onRefresh();

    // 广播上下文刷新完成事件
    publishEvent(new ContextRefreshedEvent(this));

    // 将spring容器注册到LiveBeansView
    // 和MBeanServer和MBean有关的。相当于把当前容器上下文，注册到MBeanServer里面去。
    // MBeanServer持有了容器的引用，就可以拿到容器的所有内容，也就让Spring支持到了MBean的相关功能
    LiveBeansView.registerApplicationContext(this);
}

​

4、预告： 下一篇幅将对Spring Bean的实例化过程源码部分以及AOP容器的创建及调用流程做详细分析。

本文转载自: 掘金

开发者博客 – 和开发相关的 这里全都有

0%