Spring源码学习之路---深度分析IOC容器初始化过程（四）

原文地址：https://blog.csdn.net/zuoxiaolong8810/article/details/8566927

             最近由于工作和生活，学习耽搁了几天，今天我们继续接着上一章，分析FileSystemXmlApplicationContext的构造函数，到底都做了什么，导致IOC容器初始化成功。

[java]  view plain  copy

1. public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)  
2.             throws BeansException {  
3.   
4.         super(parent);  
5.         setConfigLocations(configLocations);  
6.         if (refresh) {  
7.             refresh();  
8.         }  
9.     }  

             我们跟踪上一章FileSystemXmlApplicationContext的构造函数，可以发现它最终调用的是上面这个形式重载的构造函数，其中的refresh方法，便是IOC容器初始化的入口。下面我们继续跟踪代码进去看一下refresh方法。refresh方法位于AbstractApplicationContext中，这是一个抽象类，初步实现了ApplicationContext的一般功能，并且这里使用了模板模式，给以后要实现的子类提供了统一的模板。

[java]  view plain  copy

1. public void refresh() throws BeansException, IllegalStateException {  
2.         synchronized (this.startupShutdownMonitor) {  
3.             // Prepare this context for refreshing.  
4.             prepareRefresh();  
5.   
6.             // Tell the subclass to refresh the internal bean factory.  
7.             ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();  
8.   
9.             // Prepare the bean factory for use in this context.  
10.             prepareBeanFactory(beanFactory);  
11.   
12.             try {  
13.                 // Allows post-processing of the bean factory in context subclasses.  
14.                 postProcessBeanFactory(beanFactory);  
15.   
16.                 // Invoke factory processors registered as beans in the context.  
17.                 invokeBeanFactoryPostProcessors(beanFactory);  
18.   
19.                 // Register bean processors that intercept bean creation.  
20.                 registerBeanPostProcessors(beanFactory);  
21.   
22.                 // Initialize message source for this context.  
23.                 initMessageSource();  
24.   
25.                 // Initialize event multicaster for this context.  
26.                 initApplicationEventMulticaster();  
27.   
28.                 // Initialize other special beans in specific context subclasses.  
29.                 onRefresh();  
30.   
31.                 // Check for listener beans and register them.  
32.                 registerListeners();  
33.   
34.                 // Instantiate all remaining (non-lazy-init) singletons.  
35.                 finishBeanFactoryInitialization(beanFactory);  
36.   
37.                 // Last step: publish corresponding event.  
38.                 finishRefresh();  
39.             }  
40.   
41.             catch (BeansException ex) {  
42.                 // Destroy already created singletons to avoid dangling resources.  
43.                 destroyBeans();  
44.   
45.                 // Reset 'active' flag.  
46.                 cancelRefresh(ex);  
47.   
48.                 // Propagate exception to caller.  
49.                 throw ex;  
50.             }  
51.         }  
52.     }  

                这里面列出了IOC容器初始化的大致步骤，第一步很容易看出来是初始化准备，这个方法里只是设置了一个活动标识，我们主要来看第二步，obtainFreshBeanFactory这个方法，它是用来告诉子类刷新内部的bean工厂，接下来我们跟踪进去看看。

[java]  view plain  copy

1. protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {  
2.         refreshBeanFactory();  
3.         ConfigurableListableBeanFactory beanFactory = getBeanFactory();  
4.         if (logger.isDebugEnabled()) {  
5.             logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);  
6.         }  
7.         return beanFactory;  
8.     }  

               该方法中第一句便调用了另外一个refreshBeanFactory方法，这个方法是AbstractApplicationContext中的抽象方法，具体的实现并没有在这个抽象类中实现，而是留给了子类，我们追踪到这个子类当中去看一下。该方法由子类AbstractRefreshableApplicationContext实现，我们来看

[java]  view plain  copy

1. protected final void refreshBeanFactory() throws BeansException {  
2.         if (hasBeanFactory()) {  
3.             destroyBeans();  
4.             closeBeanFactory();  
5.         }  
6.         try {  
7.             DefaultListableBeanFactory beanFactory = createBeanFactory();  
8.             beanFactory.setSerializationId(getId());  
9.             customizeBeanFactory(beanFactory);  
10.             loadBeanDefinitions(beanFactory);  
11.             synchronized (this.beanFactoryMonitor) {  
12.                 this.beanFactory = beanFactory;  
13.             }  
14.         }  
15.         catch (IOException ex) {  
16.             throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);  
17.         }  
18.     }  

            方法加上了final关键字，也就是说此方法不可被重写，可以很清楚的看到，IOC容器的初始化就是在这个方法里发生的，第一步先是判断有无现有的工厂，有的话便会将其摧毁，否则，就会创建一个默认的bean工厂，也就是前面提到的DefaultListableBeanFactory，注意看loadBeanDefinitions(beanFactory);这里，当我们创建了一个默认的bean工厂以后，便是载入bean的定义。这与我们上一章所使用的原始的创建bean工厂的方式极为相似。

           看到这里，其实不难看出，FileSystemXmlApplicationContext的初始化方法中，其实已经包含了我们上一章当中原始的创建过程，这个类是一个现有的，spring已经为我们实现好的BeanFactory的实现类。在项目当中，我们经常会用到。

           今天天色已晚，改天鄙人带着各位去看一下IOC容器建立的要义，也就是载入bean定义的实现。