qidao123.com技术社区-IT企服评测·应用市场

标题: 从底层源码深入分析Spring的IoC容器初始化过程 [打印本页]

---

作者: 天津储鑫盛钢材现货供应商    时间: 2024-12-16 07:58
标题: 从底层源码深入分析Spring的IoC容器初始化过程
IOC容器的初始化整体过程

Spring是怎样实现将资源配置（以xml配置为例）通过加载，解析，生成BeanDefination并注册到IoC容器中的？这主要会颠末以下 4 步：

• 从XML中读取配置文件，并将配置文件转换为Document
  
• 再将Document中的 bean标签解析成 BeanDefinition，如解析 property 元素， 并注入到 BeanDefinition 实例中。
  
• 将 BeanDefinition 注册到容器 BeanDefinitionMap 中。
  
• BeanFactory 根据 BeanDefinition 的界说信息创建实例化和初始化 bean。
  

启动的入口

对于xml配置的Spring应用，在main()方法中实例化ClasspathXmlApplicationContext即可创建一个IoC容器。可以从这个构造方法开始，探究一下IoC容器的初始化过程。

1. // create and configure beans
2. ApplicationContext context = new ClassPathXmlApplicationContext("aspects.xml", "daos.xml", "services.xml");
3. public ClassPathXmlApplicationContext(String... configLocations) throws BeansException {
4.     this(configLocations, true, (ApplicationContext)null);
5. }
7. public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, @Nullable ApplicationContext parent) throws BeansException {
8.     // 设置Bean资源加载器
9.     super(parent);
11.     // 设置配置路径
12.     this.setConfigLocations(configLocations);
14.     // 初始化容器
15.     if (refresh) {
16.         this.refresh();
17.     }
18. }

复制代码

这里的作用就是加载了一个解析配置文件路径的加载器，然后通过系统情况变量拿到这个配置文件，进行一些配置文件的去空格，转换表达式等等操作(留意，这里没有进行解析)；最后通过 refresh方法 完成了几乎所有的工作。

设置资源解析器和情况

调用父类容器AbstractApplicationContext的构造方法(super(parent)方法)为容器设置好Bean资源加载器

1. public AbstractApplicationContext(@Nullable ApplicationContext parent) {
2.     // 默认构造函数初始化容器id, name, 状态 以及 资源解析器
3.     this();
5.     // 将父容器的Environment合并到当前容器
6.     this.setParent(parent);
7. }

复制代码

通过AbstractApplicationContext默认构造函数初始化容器id, name, 状态 以及 资源解析器

1. public AbstractApplicationContext() {
2.     this.logger = LogFactory.getLog(this.getClass());
3.     this.id = ObjectUtils.identityToString(this);
4.     this.displayName = ObjectUtils.identityToString(this);
5.     this.beanFactoryPostProcessors = new ArrayList();
6.     this.active = new AtomicBoolean();
7.     this.closed = new AtomicBoolean();
8.     this.startupShutdownMonitor = new Object();
9.     this.applicationStartup = ApplicationStartup.DEFAULT;
10.     this.applicationListeners = new LinkedHashSet();
11.     this.resourcePatternResolver = this.getResourcePatternResolver();
12. }
13. // Spring资源加载器
14. protected ResourcePatternResolver getResourcePatternResolver() {
15.     return new PathMatchingResourcePatternResolver(this);
16. }

复制代码

通过AbstractApplicationContext的setParent(parent)方法将父容器的Environment合并到当前容器

1. public void setParent(@Nullable ApplicationContext parent) {
2.     this.parent = parent;
3.     if (parent != null) {
4.         Environment parentEnvironment = parent.getEnvironment();
5.         if (parentEnvironment instanceof ConfigurableEnvironment) {
6.             this.getEnvironment().merge((ConfigurableEnvironment)parentEnvironment);
7.         }
8.     }
9. }

复制代码

设置配置路径

在设置容器的资源加载器之后，接下来FileSystemXmlApplicationContet实行setConfigLocations方法通过调用其父类AbstractRefreshableConfigApplicationContext的方法进行对Bean界说资源文件的定位

1. public void setConfigLocations(@Nullable String... locations) {
2.     if (locations != null) {
3.         Assert.noNullElements(locations, "Config locations must not be null");
4.         this.configLocations = new String[locations.length];
6.         for(int i = 0; i < locations.length; ++i) {
7.             // 解析配置路径
8.             this.configLocations[i] = this.resolvePath(locations[i]).trim();
9.         }
10.     } else {
11.         this.configLocations = null;
12.     }
13. }
14. protected String resolvePath(String path) {
15.     // 从上一步Environment中解析
16.     return this.getEnvironment().resolveRequiredPlaceholders(path);
17. }

复制代码

启动的主体流程

Spring IoC容器对Bean界说资源的载入是从refresh()函数开始的，refresh()是一个模板方法

refresh()方法的作用是：在创建IoC容器前，如果已经有容器存在，则需要把已有的容器烧毁和关闭，以保证在refresh之后使用的是新建立起来的IoC容器。refresh的作用类似于对IoC容器的重启，在新建立好的容器中对容器进行初始化，对Bean界说资源进行载入。

1. @Override
2. public void refresh() throws BeansException, IllegalStateException {
3.     synchronized (this.startupShutdownMonitor) {
4.         StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
6.         //① 容器刷新前的准备工作
7.         prepareRefresh();
9.         //② 调用子类容器的refreshBeanFactory()方法，启动容器载入Bean定义资源文件的过程
10.         ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
12.         //③ 准备Bean工厂
13.         prepareBeanFactory(beanFactory);
15.         try {
16.             //④ 子类扩展BeanFactory
17.             postProcessBeanFactory(beanFactory);
19.             StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
20.             //⑤ 执行增强方法
21.             invokeBeanFactoryPostProcessors(beanFactory);
23.             //⑥ 注册BeanPostProcessors，但没执行
24.             registerBeanPostProcessors(beanFactory);
25.             beanPostProcess.end();
27.             //⑦ 执行国际化内容
28.             initMessageSource();
30.             //⑧ 创建了一个多播器，为添加`Listener`提供支持。
31.             initApplicationEventMulticaster();
33.             //⑨ 子类扩展
34.             onRefresh();
36.             //⑩ Check for listener beans and register them.
37.             registerListeners();
39.             //⑪ Instantiate all remaining (non-lazy-init) singletons.
40.             finishBeanFactoryInitialization(beanFactory);
42.             // Last step: publish corresponding event.
43.             finishRefresh();
44.         }
46.         catch (BeansException ex) {
47.             if (logger.isWarnEnabled()) {
48.                 logger.warn("Exception encountered during context initialization - " +
49.                         "cancelling refresh attempt: " + ex);
50.             }
52.             // Destroy already created singletons to avoid dangling resources.
53.             destroyBeans();
55.             // Reset 'active' flag.
56.             cancelRefresh(ex);
58.             // Propagate exception to caller.
59.             throw ex;
60.         }
62.         finally {
63.             // Reset common introspection caches in Spring's core, since we
64.             // might not ever need metadata for singleton beans anymore...
65.             resetCommonCaches();
66.             contextRefresh.end();
67.         }
68.     }
69. }@Override
70. public void refresh() throws BeansException, IllegalStateException {
71.     synchronized (this.startupShutdownMonitor) {
72.         StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
74.         //① 容器刷新前的准备工作
75.         prepareRefresh();
77.         //② 调用子类容器的refreshBeanFactory()方法，启动容器载入Bean定义资源文件的过程
78.         ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
80.         //③ 准备Bean工厂
81.         prepareBeanFactory(beanFactory);
83.         try {
84.             //④ 子类扩展BeanFactory
85.             postProcessBeanFactory(beanFactory);
87.             StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
88.             //⑤ 执行增强方法
89.             invokeBeanFactoryPostProcessors(beanFactory);
91.             //⑥ 注册BeanPostProcessors，但没执行
92.             registerBeanPostProcessors(beanFactory);
93.             beanPostProcess.end();
95.             //⑦ 执行国际化内容
96.             initMessageSource();
98.             //⑧ 创建了一个多播器，为添加`Listener`提供支持。
99.             initApplicationEventMulticaster();
101.             //⑨ 子类扩展
102.             onRefresh();
104.             //⑩ Check for listener beans and register them.
105.             registerListeners();
107.             //⑪ Instantiate all remaining (non-lazy-init) singletons.
108.             finishBeanFactoryInitialization(beanFactory);
110.             // Last step: publish corresponding event.
111.             finishRefresh();
112.         }
114.         catch (BeansException ex) {
115.             if (logger.isWarnEnabled()) {
116.                 logger.warn("Exception encountered during context initialization - " +
117.                         "cancelling refresh attempt: " + ex);
118.             }
120.             // Destroy already created singletons to avoid dangling resources.
121.             destroyBeans();
123.             // Reset 'active' flag.
124.             cancelRefresh(ex);
126.             // Propagate exception to caller.
127.             throw ex;
128.         }
130.         finally {
131.             // Reset common introspection caches in Spring's core, since we
132.             // might not ever need metadata for singleton beans anymore...
133.             resetCommonCaches();
134.             contextRefresh.end();
135.         }
136.     }
137. }

复制代码

这里的设计上是一个非常典范的资源类加载处理型的思路，头脑中需要形成如下图的顶层思路（而不是只停留在流水式的方法上面）：

• 模板方法设计模式，模板方法中使用典范的钩子方法
  
• 将具体的初始化加载方法插入到钩子方法之间
  
• 将初始化的阶段封装，用来记载当前初始化到什么阶段；常见的设计是xxxPhase/xxxStage；
  
• 资源加载初始化有失败等处理，一定是try/catch/finally...
  

① prepareRefresh 准备上下文情况

1. protected void prepareRefresh() {
2.     //1、设置启动时间、一些标志位
3.    
4.     //设置容器的启动时间
5.     this.startupDate = System.currentTimeMillis();
6.     //设置容器的启动时间
7.     this.closed.set(false);
8.     //设置容器的激活标志位
9.     this.active.set(true);
10.     if (this.logger.isDebugEnabled()) {
11.         if (this.logger.isTraceEnabled()) {
12.             this.logger.trace("Refreshing " + this);
13.         } else {
14.             this.logger.debug("Refreshing " + this.getDisplayName());
15.         }
16.     }
17.    
18.     //2、初始化占位符属性源，留给子类实现
19.     this.initPropertySources();
20.    
21.     //3、验证并获取环境对象，验证需要的属性是否都已经放入环境对象中
22.     this.getEnvironment().validateRequiredProperties();
23.    
24.     //4、判断刷新前的应用程序监听器集合是否为空，如果为空，则将监听器添加到此集合中
25.     if (this.earlyApplicationListeners == null) {
26.         this.earlyApplicationListeners = new LinkedHashSet(this.applicationListeners);
27.     } else {
28.         //如果不为空，清空集合
29.         this.applicationListeners.clear();
30.         this.applicationListeners.addAll(this.earlyApplicationListeners);
31.     }
33.     this.earlyApplicationEvents = new LinkedHashSet();
34. }

复制代码

② obtainFreshBeanFactory 创建工厂

这个方法主要就是创建了一个工厂BeanFactory，并且解析了配置文件，加载了Bean界说信息

AbstractApplicationContext的obtainFreshBeanFactory()方法调用子类容器的refreshBeanFactory()方法，启动容器载入Bean界说资源文件的过程，代码如下：

1. protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
2.     // 这里使用了委派设计模式，父类定义了抽象的refreshBeanFactory()方法，具体实现调用子类容器的refreshBeanFactory()方法
3.     refreshBeanFactory();
4.     return getBeanFactory();
5. }

复制代码

AbstractApplicationContext类中只抽象界说了refreshBeanFactory()方法，如下：

1. //org.springframework.context.support.AbstractApplicationContext#refreshBeanFactory
2. protected abstract void refreshBeanFactory() throws BeansException, IllegalStateException;

复制代码

容器真正调用的是其子类AbstractRefreshableApplicationContext实现的refreshBeanFactory()方法；在创建IoC容器前，如果已经有容器存在，则需要把已有的容器烧毁和关闭，以保证在refresh之后使用的是新建立起来的IoC容器。方法的源码如下：

1. protected final void refreshBeanFactory() throws BeansException {
2.     // 如果已经有容器存在，则需要把已有的容器销毁和关闭，以保证在refresh之后使用的是新建立起来的IoC容器
3.     if (hasBeanFactory()) {
4.         destroyBeans();
5.         closeBeanFactory();
6.     }
7.     try {
8.         // 创建DefaultListableBeanFactory，并调用loadBeanDefinitions(beanFactory)装载bean定义
9.         DefaultListableBeanFactory beanFactory = createBeanFactory();
10.         beanFactory.setSerializationId(getId());
11.         customizeBeanFactory(beanFactory); // 对IoC容器进行定制化，如设置启动参数，开启注解的自动装配等
12.         loadBeanDefinitions(beanFactory); // 调用载入Bean定义的方法，主要这里又使用了一个委派模式，在当前类中只定义了抽象的loadBeanDefinitions方法，具体的实现调用子类容器  
13.         this.beanFactory = beanFactory;
14.     }
15.     catch (IOException ex) {
16.         throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
17.     }
18. }

复制代码

loadBeanDefinitions

AbstractRefreshableApplicationContext 中只界说了抽象的 loadBeanDefinitions 方法，容器真正调用的是其子类 AbstractXmlApplicationContext 对该方法的实现，AbstractXmlApplicationContext 的主要源码如下：

1. protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
2.     // 创建XmlBeanDefinitionReader，即创建Bean读取器，并通过回调设置到容器中去，容器使用该读取器读取Bean定义资源  
3.     XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
5.     // 配置上下文的环境，资源加载器、解析器
6.     beanDefinitionReader.setEnvironment(this.getEnvironment());
7.     beanDefinitionReader.setResourceLoader(this);
8.     beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this)); // 为Bean读取器设置SAX xml解析器
10.     // 允许子类自行初始化（比如校验机制），并提供真正的加载方法
11.     initBeanDefinitionReader(beanDefinitionReader); // 当Bean读取器读取Bean定义的Xml资源文件时，启用Xml的校验机制  
12.     loadBeanDefinitions(beanDefinitionReader);
13. }
15. protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
16.     // 加载XML配置方式里的Bean定义的资源
17.     Resource[] configResources = getConfigResources();
18.     if (configResources != null) {
19.         reader.loadBeanDefinitions(configResources);
20.     }
21.     // 加载构造函数里配置的Bean配置文件，即{"aspects.xml", "daos.xml", "services.xml"}
22.     String[] configLocations = getConfigLocations();
23.     if (configLocations != null) {
24.         reader.loadBeanDefinitions(configLocations);
25.     }
26. }

复制代码

Xml Bean读取器(XmlBeanDefinitionReader)调用其父类AbstractBeanDefinitionReader的 reader.loadBeanDefinitions方法读取Bean界说资源。
由于这里使用 ClassPathXmlApplicationContext 作为例子分析，因此 getConfigResources 的返回值为null，因此程序实行reader.loadBeanDefinitions(configLocations)分支。
AbstractBeanDefinitionReader读取Bean界说资源

AbstractBeanDefinitionReader的loadBeanDefinitions方法源码如下：

1. @Override
2. public int loadBeanDefinitions(String location) throws BeanDefinitionStoreException {
3.     return loadBeanDefinitions(location, null);
4. }
6. public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDefinitionStoreException {
7.     ResourceLoader resourceLoader = getResourceLoader();
8.     if (resourceLoader == null) {
9.         throw new BeanDefinitionStoreException(
10.                 "Cannot load bean definitions from location [" + location + "]: no ResourceLoader available");
11.     }
13.     // 模式匹配类型的解析器，这种方式是加载多个满足匹配条件的资源
14.     if (resourceLoader instanceof ResourcePatternResolver) {
15.         try {
16.             // 获取到要加载的资源
17.             Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
18.             int count = loadBeanDefinitions(resources); // 委派调用其子类XmlBeanDefinitionReader的方法，实现加载功能  
19.             if (actualResources != null) {
20.                 Collections.addAll(actualResources, resources);
21.             }
22.             if (logger.isTraceEnabled()) {
23.                 logger.trace("Loaded " + count + " bean definitions from location pattern [" + location + "]");
24.             }
25.             return count;
26.         }
27.         catch (IOException ex) {
28.             throw new BeanDefinitionStoreException(
29.                     "Could not resolve bean definition resource pattern [" + location + "]", ex);
30.         }
31.     }
32.     else {
33.         // 只能通过绝对路径URL加载单个资源.
34.         Resource resource = resourceLoader.getResource(location);
35.         int count = loadBeanDefinitions(resource);
36.         if (actualResources != null) {
37.             actualResources.add(resource);
38.         }
39.         if (logger.isTraceEnabled()) {
40.             logger.trace("Loaded " + count + " bean definitions from location [" + location + "]");
41.         }
42.         return count;
43.     }
44. }

复制代码

从对AbstractBeanDefinitionReader的loadBeanDefinitions方法源码分析可以看出该方法做了以下两件事：

• 首先，调用资源加载器的获取资源方法resourceLoader.getResource(location)，获取到要加载的资源。
  
• 其次，真正实行加载功能是其子类XmlBeanDefinitionReader的loadBeanDefinitions方法。
  

XmlBeanDefinitionReader加载Bean界说资源

XmlBeanDefinitionReader的loadBeanDefinitions方法主要是调用了 loadBeanDefinitions(Resource …) 方法，可以看到代表bean文件的资源界说以后的载入过程。

1. /**
2. * 本质上是加载XML配置的Bean。
3. * @param inputSource the SAX InputSource to read from
4. * @param resource the resource descriptor for the XML file
5. */
6. protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
7.         throws BeanDefinitionStoreException {
9.     try {
10.         Document doc = doLoadDocument(inputSource, resource); // 将Bean定义资源转换成Document对象
11.         int count = registerBeanDefinitions(doc, resource);
12.         if (logger.isDebugEnabled()) {
13.             logger.debug("Loaded " + count + " bean definitions from " + resource);
14.         }
15.         return count;
16.     }
17.     catch (BeanDefinitionStoreException ex) {
18.         throw ex;
19.     }
20.     catch (SAXParseException ex) {
21.         throw new XmlBeanDefinitionStoreException(resource.getDescription(),
22.                 "Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);
23.     }
24.     catch (SAXException ex) {
25.         throw new XmlBeanDefinitionStoreException(resource.getDescription(),
26.                 "XML document from " + resource + " is invalid", ex);
27.     }
28.     catch (ParserConfigurationException ex) {
29.         throw new BeanDefinitionStoreException(resource.getDescription(),
30.                 "Parser configuration exception parsing XML from " + resource, ex);
31.     }
32.     catch (IOException ex) {
33.         throw new BeanDefinitionStoreException(resource.getDescription(),
34.                 "IOException parsing XML document from " + resource, ex);
35.     }
36.     catch (Throwable ex) {
37.         throw new BeanDefinitionStoreException(resource.getDescription(),
38.                 "Unexpected exception parsing XML document from " + resource, ex);
39.     }
40. }
42. // 使用配置的DocumentLoader加载XML定义文件为Document.
43. protected Document doLoadDocument(InputSource inputSource, Resource resource) throws Exception {
44.     return this.documentLoader.loadDocument(inputSource, getEntityResolver(), this.errorHandler,
45.             getValidationModeForResource(resource), isNamespaceAware());
46. }

复制代码

通过源码分析，载入Bean界说资源文件的最后一步是将Bean界说资源转换为Document对象，该过程由documentLoader实现
DocumentLoader将Bean界说资源转换为Document对象

DocumentLoader将Bean界说资源转换成Document对象的源码如下：

1. // 使用标准的JAXP将载入的Bean定义资源转换成document对象
2. @Override
3. public Document loadDocument(InputSource inputSource, EntityResolver entityResolver,
4.         ErrorHandler errorHandler, int validationMode, boolean namespaceAware) throws Exception {
6.     // 创建文件解析器工厂
7.     DocumentBuilderFactory factory = createDocumentBuilderFactory(validationMode, namespaceAware);
8.     if (logger.isTraceEnabled()) {
9.         logger.trace("Using JAXP provider [" + factory.getClass().getName() + "]");
10.     }
11.     // 创建文档解析器
12.     DocumentBuilder builder = createDocumentBuilder(factory, entityResolver, errorHandler);
13.     return builder.parse(inputSource); // 解析
14. }
16. protected DocumentBuilderFactory createDocumentBuilderFactory(int validationMode, boolean namespaceAware)
17.         throws ParserConfigurationException {
19.     DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
20.     factory.setNamespaceAware(namespaceAware);
22.     // 设置解析XML的校验
23.     if (validationMode != XmlValidationModeDetector.VALIDATION_NONE) {
24.         factory.setValidating(true);
25.         if (validationMode == XmlValidationModeDetector.VALIDATION_XSD) {
26.             // Enforce namespace aware for XSD...
27.             factory.setNamespaceAware(true);
28.             try {
29.                 factory.setAttribute(SCHEMA_LANGUAGE_ATTRIBUTE, XSD_SCHEMA_LANGUAGE);
30.             }
31.             catch (IllegalArgumentException ex) {
32.                 ParserConfigurationException pcex = new ParserConfigurationException(
33.                         "Unable to validate using XSD: Your JAXP provider [" + factory +
34.                         "] does not support XML Schema. Are you running on Java 1.4 with Apache Crimson? " +
35.                         "Upgrade to Apache Xerces (or Java 1.5) for full XSD support.");
36.                 pcex.initCause(ex);
37.                 throw pcex;
38.             }
39.         }
40.     }
42.     return factory;
43. }

复制代码

该解析过程调用JavaEE尺度的JAXP尺度进行处理。
至此Spring IoC容器根据定位的Bean界说资源文件，将其加载读入并转换成为Document对象过程完成。
接下来继续分析Spring IoC容器将载入的Bean界说资源文件转换为Document对象之后，是怎样将其解析为Spring IoC管理的Bean对象并将其注册到容器中的。
XmlBeanDefinitionReader解析载入的Bean界说资源文件

XmlBeanDefinitionReader类中的doLoadBeanDefinitions方法是从特定XML文件中实际载入Bean界说资源的方法，该方法在载入Bean界说资源之后将其转换为Document对象，接下来调用registerBeanDefinitions启动Spring IoC容器对Bean界说的解析过程，registerBeanDefinitions方法源码如下：

1. // 按照Spring的Bean语义要求将Bean定义资源解析并转换为容器内部数据结构
2. public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
3.     BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
4.     int countBefore = getRegistry().getBeanDefinitionCount();
5.     // 解析过程入口，这里使用了委派模式，具体的解析实现过程由实现类DefaultBeanDefinitionDocumentReader完成  
6.     documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
7.     return getRegistry().getBeanDefinitionCount() - countBefore;  // 返回此次解析了多少个对象
8. }
10. // 创建BeanDefinitionDocumentReader对象，解析Document对象  
11. protected BeanDefinitionDocumentReader createBeanDefinitionDocumentReader() {
12.     return BeanUtils.instantiateClass(this.documentReaderClass);
13. }
15. /**
16. * Create the {@link XmlReaderContext} to pass over to the document reader.
17. */
18. public XmlReaderContext createReaderContext(Resource resource) {
19.     return new XmlReaderContext(resource, this.problemReporter, this.eventListener,
20.             this.sourceExtractor, this, getNamespaceHandlerResolver());
21. }

复制代码

Bean界说资源的载入解析分为以下两个过程：

• 首先，通过调用XML解析器将Bean界说资源文件转换得到Document对象，但是这些Document对象并没有按照Spring的Bean规则进行解析。这一步是载入的过程
  
• 其次，在完成通用的XML解析之后，按照Spring的Bean规则对Document对象进行解析。
  

在这个方法中很好地应用了面向对象中单一职责的原则，将逻辑处理委托给单一的类进行处理，而这个逻辑处理类就是BeanDefinitionDocumentReader。BeanDefinitionDocumentReader是一个接口，而实例化的工作是在createBeanDefinitionDocumentReader()中完成的，而通过此方法，BeanDefinitionDocumentReader真正的类型其实已经是DefaultBeanDefinitionDocumentReader了。按照Spring的Bean规则对Document对象解析的过程是在接口BeanDefinitionDocumentReader的实现类DefaultBeanDefinitionDocumentReader中实现的。
DefaultBeanDefinitionDocumentReader对Bean界说的Document对象解析

BeanDefinitionDocumentReader接口通过registerBeanDefinitions方法调用其实现类DefaultBeanDefinitionDocumentReader对Document对象进行解析，解析的代码如下：

1. @Override
2. public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
3.     this.readerContext = readerContext;
4.     doRegisterBeanDefinitions(doc.getDocumentElement());
5. }
7. // 注册<beans/>配置的Beans
8. @SuppressWarnings("deprecation")  // for Environment.acceptsProfiles(String...)
9. protected void doRegisterBeanDefinitions(Element root) {
10.     // Any nested <beans> elements will cause recursion in this method. In
11.     // order to propagate and preserve <beans> default-* attributes correctly,
12.     // keep track of the current (parent) delegate, which may be null. Create
13.     // the new (child) delegate with a reference to the parent for fallback purposes,
14.     // then ultimately reset this.delegate back to its original (parent) reference.
15.     // this behavior emulates a stack of delegates without actually necessitating one.
16.     BeanDefinitionParserDelegate parent = this.delegate;
17.     this.delegate = createDelegate(getReaderContext(), root, parent);
19.     if (this.delegate.isDefaultNamespace(root)) {
20.         //专门对 profile 标签进行解析
21.         String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
22.         if (StringUtils.hasText(profileSpec)) {
23.             String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
24.                     profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
25.             // We cannot use Profiles.of(...) since profile expressions are not supported
26.             // in XML config. See SPR-12458 for details.
27.             //
28.             if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
29.                 if (logger.isDebugEnabled()) {
30.                     logger.debug("Skipped XML bean definition file due to specified profiles [" + profileSpec +
31.                             "] not matching: " + getReaderContext().getResource());
32.                 }
33.                 return;
34.             }
35.         }
36.     }
38.    
39.     preProcessXml(root);//解析前处理，留给子类实现
40.     parseBeanDefinitions(root, this.delegate); // 从Document的根元素开始进行Bean定义的Document对象  
41.     postProcessXml(root);//解析后处理，留给子类实现
43.     this.delegate = parent;
44. }

复制代码

这里我们留意到在注册Bean的最开始是对PROFILE_ATTRIBUTE属性的解析，有了 profile 这个特性我们就可以同时在配置文件中部署两套配置来适用于生产情况和开发情况，这样可以方便的进行切换开发、部署情况，最常用的就是更换不同的数据库。
首先程序会获取beans节点是否界说了profile属性，如果界说了则会需要到情况变量中去寻找，由于profile是可以同时指定多个的，需要程序对其拆分，并解析每个profile是都符合情况变量中所界说的，不界说则不会浪费性能去解析。

留意：跟进 preProcessXml(root) 和 postProcessXml(root) 后发现代码是空的。
记住，一个类要么是面向继续设计，要么是final修饰的。而这个类并不是final修饰的，那么就是面向继续设计的，显然这里是用到了模板方法设计模式，如果继续自DefaultBeanDefinitionDocumentReader的子类需要在Bean解析前后做一些处理的话，那么只需要重写这两个方法即可

BeanDefinitionParserDelegate解析Bean界说资源文件生成BeanDefinition

处理了profile后就可以进行XML的读取了，跟踪代码进入parseBeanDefinitions(root, this.delegate)。

1. /**
2.     * Parse the elements at the root level in the document:
3.     * "import", "alias", "bean".
4.     * @param root the DOM root element of the document
5.     */
6. protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
7.     if (delegate.isDefaultNamespace(root)) {
8.         NodeList nl = root.getChildNodes();
9.         for (int i = 0; i < nl.getLength(); i++) {
10.             Node node = nl.item(i);
11.             if (node instanceof Element) {
12.                 Element ele = (Element) node;
13.                 if (delegate.isDefaultNamespace(ele)) {
14.                     //对默认标签解析
15.                     parseDefaultElement(ele, delegate);
16.                 }
17.                 else {
18.                     //对默认自定义标签的解析
19.                     delegate.parseCustomElement(ele);
20.                 }
21.             }
22.         }
23.     }
24.     else {
25.         delegate.parseCustomElement(root);
26.     }
27. }

复制代码

上面的代码看起来逻辑照旧蛮清晰的，由于在Spring的XML配置里面有两大类Bean声明，一个是默认的，如：

1. [/code]另一类就是自界说的，如：
2. [code]

复制代码

而两种方式的读取及解析差异是非常大的，如果接纳Spring默认的配置，Spring当然知道该怎么做，但是如果是自界说的，那么就需要用户实现一些接口及配置了。对于根节点大概子节点如果是默认定名空间的话则接纳parseDefaultElement方法进行解析，否则使用delegate.parseCustomElement方法对自界说定名空间进行解析。而判断是否默认定名空间照旧自界说定名空间的办法其实是使用node.getNamespaceURI()获取定名空间，并与Spring中固定的定名空间http://www.Springframework.org/schema/beans进行比对。如果同等则认为是默认，否则就认为是自界说。
默认标签的解析

1. private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
2.       
3.     // 如果元素节点是<Import>导入元素，进行导入解析
4.     if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
5.         importBeanDefinitionResource(ele);
6.     }
7.     // 如果元素节点是<Alias>别名元素，进行别名解析
8.     else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
9.         processAliasRegistration(ele);
10.     }
11.     // 如果元素节点<Bean>元素, 按照Spring的Bean规则解析元素  
12.     else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
13.         processBeanDefinition(ele, delegate);
14.     }
15.     // 如果元素节点<Beans>元素，即它是嵌套类型的
16.     else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
17.         // 递归解析
18.         doRegisterBeanDefinitions(ele);
19.     }
20. }

复制代码

委托BeanDefinitionDelegate类的parseBeanDefinitionElement方法进行元素解析，返回BeanDefinitionHolder类型的实例bdHolder，颠末这个方法后，bdHolder实例已经包含我们配置文件中配置的各种属性了，例如class、name、id、alias之类的属性。

1. /**
2. * Process the given bean element, parsing the bean definition
3. * and registering it with the registry.
4. */
5. protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
6.     BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
7.     if (bdHolder != null) {
8.         bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
9.         try {
10.             // 注册最终的装饰实例
11.             BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
12.         }
13.         catch (BeanDefinitionStoreException ex) {
14.             getReaderContext().error("Failed to register bean definition with name '" +
15.                     bdHolder.getBeanName() + "'", ele, ex);
16.         }
17.         // Send registration event.
18.         getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
19.     }
20. }

复制代码

parseBeanDefinitionElement的解析方法 就不一一展开了，无非就是解析XML各种元素，来生成BeanDefinition。解析的过程与mybatis解析xml文件同理，详情可以看这篇文章
自界说标签的解析

在实际项目中，较少进行自界说标签，因此这里不展开描述了。
解析过后的BeanDefinition在IoC容器中的注册

Document对象的解析后得到封装 BeanDefinition 的 BeanDefinitionHold 对象，然后调用 BeanDefinitionReaderUtils 的 registerBeanDefinition 方法向IoC容器注册解析的Bean，BeanDefinitionReaderUtils的注册的源码如下：

1. // 通过BeanDefinitionRegistry将BeanDefinitionHolder注册到BeanFactory
2. public static void registerBeanDefinition(
3.         BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
4.         throws BeanDefinitionStoreException {
6.     // Register bean definition under primary name.
7.     String beanName = definitionHolder.getBeanName();
8.     registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
10.     // Register aliases for bean name, if any.
11.     String[] aliases = definitionHolder.getAliases();
12.     if (aliases != null) {
13.         for (String alias : aliases) {
14.             registry.registerAlias(beanName, alias);
15.         }
16.     }
17. }

复制代码

当调用BeanDefinitionReaderUtils向IoC容器注册解析的BeanDefinition时，真正完成注册功能的是DefaultListableBeanFactory。
DefaultListableBeanFactory向IoC容器注册解析后的BeanDefinition

IOC容器本质上就是一个beanDefinitionMap， 注册即将BeanDefinition put到map中

1. /** Map of bean definition objects, keyed by bean name. */
2. private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);
4. /** Map from bean name to merged BeanDefinitionHolder. */
5. private final Map<String, BeanDefinitionHolder> mergedBeanDefinitionHolders = new ConcurrentHashMap<>(256);
8. @Override
9. public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
10.         throws BeanDefinitionStoreException {
12.     Assert.hasText(beanName, "Bean name must not be empty");
13.     Assert.notNull(beanDefinition, "BeanDefinition must not be null");
15.     if (beanDefinition instanceof AbstractBeanDefinition) {
16.         try {
17.             ((AbstractBeanDefinition) beanDefinition).validate();
18.         }
19.         catch (BeanDefinitionValidationException ex) {
20.             throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
21.                     "Validation of bean definition failed", ex);
22.         }
23.     }
25.     BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
26.     // 如果已经注册
27.     if (existingDefinition != null) {
28.         // 检查是否可以覆盖
29.         if (!isAllowBeanDefinitionOverriding()) {
30.             throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
31.         }
32.         else if (existingDefinition.getRole() < beanDefinition.getRole()) {
33.             // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
34.             if (logger.isInfoEnabled()) {
35.                 logger.info("Overriding user-defined bean definition for bean '" + beanName +
36.                         "' with a framework-generated bean definition: replacing [" +
37.                         existingDefinition + "] with [" + beanDefinition + "]");
38.             }
39.         }
40.         else if (!beanDefinition.equals(existingDefinition)) {
41.             if (logger.isDebugEnabled()) {
42.                 logger.debug("Overriding bean definition for bean '" + beanName +
43.                         "' with a different definition: replacing [" + existingDefinition +
44.                         "] with [" + beanDefinition + "]");
45.             }
46.         }
47.         else {
48.             if (logger.isTraceEnabled()) {
49.                 logger.trace("Overriding bean definition for bean '" + beanName +
50.                         "' with an equivalent definition: replacing [" + existingDefinition +
51.                         "] with [" + beanDefinition + "]");
52.             }
53.         }
54.         // 覆盖
55.         this.beanDefinitionMap.put(beanName, beanDefinition);
56.     }
57.     else {
58.         if (hasBeanCreationStarted()) {
59.             // Cannot modify startup-time collection elements anymore (for stable iteration)
60.             synchronized (this.beanDefinitionMap) {
61.                 this.beanDefinitionMap.put(beanName, beanDefinition);
62.                 List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
63.                 updatedDefinitions.addAll(this.beanDefinitionNames);
64.                 updatedDefinitions.add(beanName);
65.                 this.beanDefinitionNames = updatedDefinitions;
66.                 removeManualSingletonName(beanName);
67.             }
68.         }
69.         else {
70.             // Still in startup registration phase
71.             this.beanDefinitionMap.put(beanName, beanDefinition);
72.             this.beanDefinitionNames.add(beanName);
73.             removeManualSingletonName(beanName);
74.         }
75.         //重置所有已经注册过的BeanDefinition的缓存  
76.         this.frozenBeanDefinitionNames = null;
77.     }
79.     if (existingDefinition != null || containsSingleton(beanName)) {
80.         resetBeanDefinition(beanName);
81.     }
82.     else if (isConfigurationFrozen()) {
83.         clearByTypeCache();
84.     }
85. }

复制代码

至此，Bean界说资源文件中配置的Bean被解析过后，已经注册到IoC容器中，被容器管理起来，真正完成了IoC容器初始化所做的全部工作。如今IoC容器中已经建立了整个Bean的配置信息，这些 BeanDefinition 信息已经可以使用，并且可以被检索，IoC容器的作用就是对这些注册的Bean界说信息进行处理和维护。这些的注册的Bean界说信息是IoC容器控制反转的基础，正是有了这些注册的数据，容器才可以进行依赖注入。
小结

如今通过上面的代码，总结一下IOC容器初始化的根本步骤：

• 初始化的入口在容器实现中的 refresh()调用来完成
  
• 对 bean 界说载入 IOC 容器使用的方法是 loadBeanDefinition，此中的大致过程如下：
  
  
  
  • 通过 ResourceLoader 来完成资源文件位置的定位，DefaultResourceLoader 是默认的实现，同时上下文本身就给出了 ResourceLoader 的实现，可以从类路径，文件系统, URL 等方式来定为资源位置。如果是 XmlBeanFactory作为 IOC 容器，那么需要为它指定 bean 界说的资源，也就是说 bean 界说文件时通过抽象成 Resource 来被 IOC 容器处理的
    
  • 通过 BeanDefinitionReader来完成界说信息的解析和 Bean 信息的注册, 往往使用的是XmlBeanDefinitionReader 来解析 bean 的 xml 界说文件 — 实际的处理过程是委托给 BeanDefinitionParserDelegate 来完成的，从而得到 bean 的界说信息，这些信息在 Spring 中使用 BeanDefinition 对象来表示
    
  • 容器解析得到 BeanDefinition 以后，需要把它在 IOC 容器中注册，这由 IOC 实现 BeanDefinitionRegistry 接口来实现。注册过程就是在 IOC 容器内部维护的一个HashMap 来保存得到的 BeanDefinition 的过程。这个 HashMap 是 IoC 容器持有 bean 信息的场合，以后对 bean 的操作都是围绕这个HashMap 来实现的.
    
  
  
• 最后可以通过 BeanFactory 和 ApplicationContext 来享受到 Spring IOC 的服务了，在使用 IOC 容器的时间，除了少量粘合代码，绝大多数以正确 IoC 风格编写的应用程序代码完全不用关心怎样到达工厂，由于容器将把这些对象与容器管理的其他对象钩在一起。根本的策略是把工厂放到已知的地方，最好是放在对预期使用的上下文有意义的地方，以及代码将实际需要访问工厂的地方。 Spring 本身提供了对声明式载入 web 应用程序用法的应用程序上下文，并将其存储在ServletContext 中的框架实现。
  

③ prepareBeanFactory 准备Bean工厂

为BeanFactory准备一些情况，方便在实例化的时间使用，同时添加容器本身的BeanPostProcessor

1. // org.springframework.context.support.AbstractApplicationContext#prepareBeanFactory
2. protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
3.     //设置bean工厂使用上下文的类加载器
4.     beanFactory.setBeanClassLoader(this.getClassLoader());
5.     //设置bean表达式解析器，默认可以使用#{bean.xxx}的形式来调用相关属性值
6.     beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
7.     //设置属性编辑器
8.     beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, this.getEnvironment()));
9.    
10.     //添加BeanPostProcessor -> Applicat ionContextAwareProcessor
11.     // AppLicationContextAwareProcessor在 postProcessBeforeInitialization()方法调用invokeAwareInterfaces(bean)
12.     // 主要外理实现Aware接的bean在被初始化之前能够获取一些对应的资源，如ApplicationContext. ResourceLoader、 Environment
13.     beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
14.    
15.     //忽略以下接口的自动装配依赖，因为前面的ApplicationContextAwareProcessor已经实现了类似功能
16.     beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
17.     beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
18.     beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
19.     beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
20.     beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
21.     beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
22.     beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
23.     beanFactory.registerResolvableDependency(ResourceLoader.class, this);
24.     beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
25.     beanFactory.registerResolvableDependency(ApplicationContext.class, this);
26.    
27.     //添加BeanPostProcessor
28.     beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
29.     if (beanFactory.containsBean("loadTimeWeaver")) {
30.         beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
31.         beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
32.     }
33.     //注册默认环境bean
34.     if (!beanFactory.containsLocalBean("environment")) {
35.         beanFactory.registerSingleton("environment", this.getEnvironment());
36.     }
38.     if (!beanFactory.containsLocalBean("systemProperties")) {
39.         beanFactory.registerSingleton("systemProperties", this.getEnvironment().getSystemProperties());
40.     }
42.     if (!beanFactory.containsLocalBean("systemEnvironment")) {
43.         beanFactory.registerSingleton("systemEnvironment", this.getEnvironment().getSystemEnvironment());
44.     }
46. }

复制代码

④ postProcessBeanFactory 子类扩展BeanFactory

1. protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
2. }       

复制代码

⑤ invokeBeanFactoryPostProcessors 实行增强的方法

这个类，涉及到了两个接口。

• BeanFactoryPostProcessor
  
• BeanDefinitionRegistryPostProcessor接口，这个接口是BeanFactoryPostProcessor的子接口，它的优先级比BeanFactoryPostProcessor更高
  

它的总体实行流程是：先实行BeanDefinitionRegistryPostProcessor的BeanFactoryPostProcessor，然后再实行BeanFactoryPostProcessor
下图是BeanDefinitionRegistryPostProcessor接口的处理过程：

BeanFactoryPostProcessor的处理逻辑
总逻辑就是先分类，已经处理过的直接跳过，没有处理过的，分类处理，逻辑和上面的雷同。
实行BeanFactoryPostProcessor后置处理器的postProcessBeanFactory()增强方法

1. protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
2.     // 1.拿到当前应用上下文beanFactoryPostProcessors变量中的值
3.     // 2.实例化并调用所有已注册的BeanFactoryPostProcessor
4.     PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, this.getBeanFactoryPostProcessors());
5.     if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean("loadTimeWeaver")) {
6.         beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
7.         beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
8.     }
9. }

复制代码

⑥ registerBeanPostProcessors

这个方法的逻辑和上面的一样，只不过上面是直接实行了BeanFactoryPostProcessor，而这个仅仅注册没实行。

首先拿到工厂中所有的BeanPostProcessor类型的Bean，然后分类处理，排序注册。
⑦ initMessageSource()

实行国际化内容
⑧ initApplicationEventMulticaster

创建了一个多播器，为添加Listener提供支持。
主要逻辑：

• 容器中是否存在applicationEventMulticaster，如果存在直接注册
  
• 如果不存在，创建一个SimpleApplicationEventMulticaster，注册到容器中。
  

⑨ onRefresh()

子类扩展
⑩ registerListeners()

观察者模式的实现
[code]protected void registerListeners() {    // 拿到当前容器中的监听器，注册到多播器中    for (ApplicationListener

---

欢迎光临 qidao123.com技术社区-IT企服评测·应用市场 (https://dis.qidao123.com/)

Powered by Discuz! X3.4