在IoC容器实现系列的上一篇中，我们简单了解了IoC容器的两大系列：BeanFactory和ApplicationContext系列。了解了它们的设计思想与应用场景。在本篇博文中，我们将继续探索IoC容器的初始化过程。
在上一篇中，我们知道IoC的初始化过程是由refresh()方法启动的，启动过程包括BeanDefinition的Resource定位、载入和注册三个过程。Spring将三个过程分开，使用不同的模块来完成，使得用户可以更加灵活的对三个过程进行剪裁或扩展，定义更加符合自己需求的IoC初始化过程。
Resource定位过程，指的是BeanDefinition的资源定位，定位过程类似于容器寻找数据的过程。由ResourceLoader统一的Resource接口来完成。BeanDefinition的载入，将用户定义好的Bean表示成IoC容器的内部数据结构（BeanDefinition）。通过BeanDefinition，使得IoC容器可以方便的对POJO对象进行管理。BeanDefinition的注册，通过调用BeanDefinitionRegistry接口的实现来完成。其实就是将BeanDefinition注入到一个HashMap中，IoC容器就是通过HashMap来持有这些BeanDefinition数据。注意：IoC容器的初始化过程，一般不包含Bean依赖注入的实现。Bean定义的载入和依赖注入是两个独立的过程。
在定位BeanDefinition是，如果使用纯粹的IoC容器，例如DefaultListableBeanFactory，则需要为它配置特定的读取器才能完成读取BeanDefinition的功能，但是这些更底层的容器可以提高定制IoC的灵活性。
在这里，我们以FileSystemXmlApplicationContext为例，通过它分析ApplicationContext的实现是如何实现Resource的定位过程。下图为ApplicationContext的继承体系。
从源码实现角度，近距离关心以FileSystemXmlApplicationContext为核心的继承体系，如下图所示。
从中可以看到FileSystemXmlApplicationContext通过继承AbstractApplicationContext具备了ResourceLoader读入以Resource定义的BeanDefinition的能力。下面具体看看FileSystemXmlApplicationContext是如何实现的。
package org.springframework.context.support; import org.springframework.beans.BeansException; import org.springframework.context.ApplicationContext; import org.springframework.core.io.FileSystemResource; import org.springframework.core.io.Resource; /* FileSystemXmlApplicationContext使用的IoC容器是DefaultListableBeanFactory */ public class FileSystemXmlApplicationContext extends AbstractXmlApplicationContext { public FileSystemXmlApplicationContext() { } public FileSystemXmlApplicationContext(ApplicationContext parent) { super(parent); } // 这个构造函数的configuration包含的是BeanDefinition所在的文件路径 public FileSystemXmlApplicationContext(String configLocation) throws BeansException { this(new String[]{configLocation}, true, (ApplicationContext)null); } // 这个构造函数允许configuration包含多个BeanDefinition的文件路径 public FileSystemXmlApplicationContext(String... configLocations) throws BeansException { this(configLocations, true, (ApplicationContext)null); } // 这个构造函数允许configuration包含多个BeanDefinition的文件路径的同时，还允许指定自己的双亲IoC容器 public FileSystemXmlApplicationContext(String[] configLocations, ApplicationContext parent) throws BeansException { this(configLocations, true, parent); } public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh) throws BeansException { this(configLocations, refresh, (ApplicationContext)null); } // 在对象初始化过程中，调用refresh函数载入BeanDefinition // 这个refresh启动了BeanDefinition的载入过程，将在下面进行详细分析 public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent) throws BeansException { super(parent); this.setConfigLocations(configLocations); if (refresh) { this.refresh(); } } // 应用文件系统中的Resource实现，通过构造一个FileSystemResource来得到一个在文件系统中定位的BeanDefinition // getResourceByPath是在BeanDefinitionReader的loadBeanDefinition中被调用的。 // loadBeanDefinition采用了模板模式，具体的定位实现实际上是由各个子类来完成的。 protected Resource getResourceByPath(String path) { if (path != null && path.startsWith("/")) { path = path.substring(1); } return new FileSystemResource(path); } }通过上述代码，我们可以看到以XML文件方式存在的BeanDefinition都能够得到有效的处理，并且在构造方法中通过refresh方法来启动IoC容器的初始化。
注意：FileSystempplicationContextContext是一个支持XML定义的BeanDefinition的ApplicationContext，可以指定以文件的形式读入BeanDefinition。在测试环境和独立应用环境中，这个ApplicationContext都是十分有用的。
对BeanDefinition资源定位的过程是由refresh方法来触发的，大致调用过程如下图所示。
在读入BeanDefinition的过程中需要使用BeanDefinitionReader，而关于这个读入器的配置，可以到FileSystemXmlApplicationContext的父类AbstractRefreshableApplicationContext中看看他是如何实现的。如果是其他类型的ApplicationContext，则会生成其他种类的Resource。
现在我们重点研究AbstractRefreshableApplicationContext的refreshBeanFactory方法的实现。它通过调用createBeanFactory创建一个IoC容器供ApplicationContext使用，同时它启动了loadBeanDefinitions来载入BeanDefinition。
protected final void refreshBeanFactory() throws BeansException { // 如果原来已经有BeanFactory，则销毁并关闭，保证每次refreshBeanFactory后产生的为新的BeanFactory if (this.hasBeanFactory()) { this.destroyBeans(); this.closeBeanFactory(); } // 这里创建并设置持有的DefaultListableBeanFactory的地方，同时并调用loadBeanDefinitions载入BeanDefinition信息 try { DefaultListableBeanFactory beanFactory = this.createBeanFactory(); // 创建IoC容器 beanFactory.setSerializationId(this.getId()); this.customizeBeanFactory(beanFactory); this.loadBeanDefinitions(beanFactory); // 启动对BeanDefinition的载入 Object var2 = this.beanFactoryMonitor; synchronized(this.beanFactoryMonitor) { this.beanFactory = beanFactory; } } catch (IOException var5) { throw new ApplicationContextException("I/O error parsing bean definition source for " + this.getDisplayName(), var5); } } // 这里就是在上下文中创建DefaultListableBeanFactory的地方，getInternalParentBeanFactory()的 // 具体实现可以参见AbstractApplicationContext中的实现，会根据容器已有的双亲IoC容器来生成 // DefaultListableBeanFactory的双亲IoC容器 protected DefaultListableBeanFactory createBeanFactory() { return new DefaultListableBeanFactory(this.getInternalParentBeanFactory()); } // 这里的载入Bean定义的有很多种方式载入，所以为抽象方法，交给具体容器完成相应的功能，委托给子类完成。 protected abstract void loadBeanDefinitions(DefaultListableBeanFactory var1) throws BeansException, IOException;其中具体资源的载入在XmlBeanDefinitionReader读入BeanDefinition时完成，具体的loadBeanDefinitions可以在XmlBeanDefinitionRead的父类AbstractBeanDefinitionReader中看到，如下所示。
public int loadBeanDefinitions(String location, Set<Resource> actualResources) throws BeanDefinitionStoreException { // 此处的ResourceLoader，使用的是DefaultResourceLoader ResourceLoader resourceLoader = this.getResourceLoader(); if (resourceLoader == null) { throw new BeanDefinitionStoreException("Cannot import bean definitions from location [" + location + "]: no ResourceLoader available"); } else { // 用于记录载入Bean的个数 int loadCount; // 调用DefaultResourceLoader的getResource完成具体的Resource定位 if (!(resourceLoader instanceof ResourcePatternResolver)) { Resource resource = resourceLoader.getResource(location); loadCount = this.loadBeanDefinitions((Resource)resource); if (actualResources != null) { actualResources.add(resource); } if (this.logger.isDebugEnabled()) { this.logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]"); } return loadCount; } else { // 通过对Resource的路径进行解析，得到Resource集合，这些集合指向定义好的BeanDefinition信息，可以使多个文件 try { Resource[] resources = ((ResourcePatternResolver)resourceLoader).getResources(location); loadCount = this.loadBeanDefinitions(resources); if (actualResources != null) { Resource[] var6 = resources; int var7 = resources.length; for(int var8 = 0; var8 < var7; ++var8) { Resource resource = var6[var8]; actualResources.add(resource); } } if (this.logger.isDebugEnabled()) { this.logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]"); } return loadCount; } catch (IOException var10) { throw new BeanDefinitionStoreException("Could not resolve bean definition resource pattern [" + location + "]", var10); } } } } // 对于取得Resource的具体过程，可以参考DefaultResourceLoader是怎样完成的。 public Resource getResource(String location) { Assert.notNull(location, "Location must not be null"); Iterator var2 = this.protocolResolvers.iterator(); Resource resource; do { if (!var2.hasNext()) { // 对路径的处理 if (location.startsWith("/")) { return this.getResourceByPath(location); } // 这里处理带有classpath标识的Resource if (location.startsWith("classpath:")) { return new ClassPathResource(location.substring("classpath:".length()), this.getClassLoader()); } // 这里处理URL表示的Resource定位 try { URL url = new URL(location); return new UrlResource(url); } catch (MalformedURLException var5) { // 如果既不是classpath，也不是URL表示的Resource，也不是普通的path，就将任务交给getResourceByPath() // 该方法为protected方法，默认实现是得到一个ClassPathContextResource，这个方法通常会用子类来实现 return this.getResourceByPath(location); } } ProtocolResolver protocolResolver = (ProtocolResolver)var2.next(); resource = protocolResolver.resolve(location, this); } while(resource == null); return resource; }在BeanDefinition的定位基础上，通过上面代码中返回的Resource对象就可以来进行BeanDefinition的载入工作了。下面，我们将开始介绍BeanDefinition的载入和解析。
在第一小节中完成了对BeanDefinition的定位后，就到了整个BeanDefinition信息的载入过程，即把定义的BeanDefinition转化为一个Spring内部表示的数据结构的过程。这些BeanDefinition数据在IoC中通过一个HashMap进行保持和维护。
我们依然从DefaultListableBeanFactory的设计入手，探索IoC容器是如何完成对BeanDefinition的载入的。在前面我们知道由refresh函数启动了IoC容器的初始化，现在我们来简单介绍一下它的实现。
该方法在AbstractApplicationContext中，详细地描述了整个ApplicationContext的初始化过程，如BeanFactory的更新，MessageSource和PostProcessor的注册等。这个过程为Bean的声明周期提供了条件，具体代码如下所示。
public void refresh() throws BeansException, IllegalStateException { Object var1 = this.startupShutdownMonitor; // 加锁，保证线程间一致性 synchronized(this.startupShutdownMonitor) { this.prepareRefresh(); // 启动子类中refreshBeanFactory()方法。 ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory(); // 准备应用于上下文的BeanFactory this.prepareBeanFactory(beanFactory); try { // 设置BeanFactory的后置处理 this.postProcessBeanFactory(beanFactory); // 调用BeanFactory的后置处理器，这些后置处理器是在Bean定义总向容器中注册的。 this.invokeBeanFactoryPostProcessors(beanFactory); // 注册Bean的后处理器，在Bean创建过程中调用。 this.registerBeanPostProcessors(beanFactory); // 初始化上下文消息源 this.initMessageSource(); // 初始化上下文的事件机制 this.initApplicationEventMulticaster(); // 初始化其他特殊Bean this.onRefresh(); // 检查监听Bean，并且将这些Bean向容器中注册 this.registerListeners(); // 实例化所有的（non-lazy-init）单件 this.finishBeanFactoryInitialization(beanFactory); // 发布容器事件，结束refresh过程 this.finishRefresh(); } catch (BeansException var9) { if (this.logger.isWarnEnabled()) { this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9); } // 为了防止Bean资源占用，在异常处理中销毁已经在前面生成的Bean单件，并且重置‘active’标志 this.destroyBeans(); this.cancelRefresh(var9); throw var9; } finally { this.resetCommonCaches(); } } }进入refreshBeanFactory方法后，创建新的BeanFactory。实例代码已经在上文中出现过，这里边不再赘述。在建立好IoC容器后，就开始了初始化过程，比如BeanDefinition的载入，具体的交互过程如下图所示。
这里调用的loadBeanDefinitions实际上为一个抽象方法，交给各个具体的容器实现该方法。在XML方式载入过程中，这个方法中在AbstractXmlApplicationContext实现，在这个loadBeanDefinitions中，初始化了读取器XmlBeanDefinitionReader，然后把读取器在IoC容器设置好，最后启动读取器来完成BeanDefinition的载入。
public abstract class AbstractXmlApplicationContext extends AbstractRefreshableConfigApplicationContext { // 此处省略了类中的其他构造方法，这里是实现loadBeanDefinitions的地方，即根据上一小节中refreshBeanFactory得到的 // BeanFactory将其中的BeanDefinitions信息载入IoC容器。 protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException { // 创建XmlBeanDefinitionReader，并设置到BeanFactory中。此处使用的BeanFactory也是DefaultListableBeanFactory XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory); beanDefinitionReader.setEnvironment(this.getEnvironment()); // 这里设置XmlBeanDefinitionReader，为XmlBeanDefinitionReader配置ResourceLoader // 因为DefaultResourceLoader是父类，所以可以直接使用this beanDefinitionReader.setResourceLoader(this); beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this)); // 启动Bean定义信息的载入过程 this.initBeanDefinitionReader(beanDefinitionReader); this.loadBeanDefinitions(beanDefinitionReader); } protected void initBeanDefinitionReader(XmlBeanDefinitionReader reader) { reader.setValidating(this.validating); } protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException { // 首先以Resource的方式得到配置文件资源的位置信息，看是否存在 Resource[] configResources = this.getConfigResources(); if (configResources != null) { reader.loadBeanDefinitions(configResources); } // 以String的形式获得配置文件的位置 String[] configLocations = this.getConfigLocations(); if (configLocations != null) { reader.loadBeanDefinitions(configLocations); } } protected Resource[] getConfigResources() { return null; } }在这里我们仅仅使用XmlBeanDefinitionReader作为示例说明，因为Spring可以对应不同形式的BeanDefinition。如果使用了其他形式的BeanDefinition，则需要使用其他种类的BeanDefinitionReader完成数据载入工作。下面我们就来看看具体载入BeanDefinition的过程。因为在AbstractBeanDefinitionReader中loadBeanDefinitions方法为抽象方法，所有应该到具体的实现读取器中方法查看相应代码，代码清单如下所示。
// 这是调用的入口方法 public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException { return this.loadBeanDefinitions(new EncodedResource(resource)); } // 以XML形式载入BeanDefinition public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException { Assert.notNull(encodedResource, "EncodedResource must not be null"); if (this.logger.isInfoEnabled()) { this.logger.info("Loading XML bean definitions from " + encodedResource.getResource()); } Set<EncodedResource> currentResources = (Set)this.resourcesCurrentlyBeingLoaded.get(); if (currentResources == null) { // 这里小编不是特别明白为什么HashSet的初始大小为4？求解 currentResources = new HashSet(4); this.resourcesCurrentlyBeingLoaded.set(currentResources); } // 如果将当前encodedResource加入到HashSet失败，则抛出异常。 if (!((Set)currentResources).add(encodedResource)) { throw new BeanDefinitionStoreException("Detected cyclic loading of " + encodedResource + " - check your import definitions!"); } else { int var5; // 这里得到XML文件，并得到IO的InputSource，准备进行读取。 try { InputStream inputStream = encodedResource.getResource().getInputStream(); try { InputSource inputSource = new InputSource(inputStream); if (encodedResource.getEncoding() != null) { inputSource.setEncoding(encodedResource.getEncoding()); } // 具体调用doLoadBeanDefinitions完成相应的BeanDefinition的载入 var5 = this.doLoadBeanDefinitions(inputSource, encodedResource.getResource()); } finally { inputStream.close(); } } catch (IOException var15) { throw new BeanDefinitionStoreException("IOException parsing XML document from " + encodedResource.getResource(), var15); } finally { ((Set)currentResources).remove(encodedResource); if (((Set)currentResources).isEmpty()) { this.resourcesCurrentlyBeingLoaded.remove(); } } return var5; } } public int loadBeanDefinitions(InputSource inputSource) throws BeanDefinitionStoreException { return this.loadBeanDefinitions(inputSource, "resource loaded through SAX InputSource"); } public int loadBeanDefinitions(InputSource inputSource, String resourceDescription) throws BeanDefinitionStoreException { return this.doLoadBeanDefinitions(inputSource, new DescriptiveResource(resourceDescription)); } // 具体的读取过程，从特定的XML文件中实际载入BeanDefinition的地方 protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource) throws BeanDefinitionStoreException { try { // 调用doLoadDocument方法得到XML文件的Doucment对象 Document doc = this.doLoadDocument(inputSource, resource); // 启动对BeanDefinition的详细解析。 return this.registerBeanDefinitions(doc, resource); } catch (BeanDefinitionStoreException var4) { throw var4; } catch (SAXParseException var5) { throw new XmlBeanDefinitionStoreException(resource.getDescription(), "Line " + var5.getLineNumber() + " in XML document from " + resource + " is invalid", var5); } catch (SAXException var6) { throw new XmlBeanDefinitionStoreException(resource.getDescription(), "XML document from " + resource + " is invalid", var6); } catch (ParserConfigurationException var7) { throw new BeanDefinitionStoreException(resource.getDescription(), "Parser configuration exception parsing XML from " + resource, var7); } catch (IOException var8) { throw new BeanDefinitionStoreException(resource.getDescription(), "IOException parsing XML document from " + resource, var8); } catch (Throwable var9) { throw new BeanDefinitionStoreException(resource.getDescription(), "Unexpected exception parsing XML document from " + resource, var9); } } // 得到XML文件的Document对象，解析过程有documentLoader完成。 // documentLoader是DefaultDocumentLoader在定义documentLoader的地方创建 protected Document doLoadDocument(InputSource inputSource, Resource resource) throws Exception { return this.documentLoader.loadDocument(inputSource, this.getEntityResolver(), this.errorHandler, this.getValidationModeForResource(resource), this.isNamespaceAware()); }在调用了registerBeanDefinitions()方法后，开始对BeanDefinition进行详细解析，而且此方法对载入的Bean还做了数量统计。
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException { // 得到BeanDefinitionDocumentReader对XML的BeanDefinition进行解析 BeanDefinitionDocumentReader documentReader = this.createBeanDefinitionDocumentReader(); int countBefore = this.getRegistry().getBeanDefinitionCount(); // 具体的解析过程在registerBeanDefinitions中完成 documentReader.registerBeanDefinitions(doc, this.createReaderContext(resource)); // 返回载入Bean的个数 return this.getRegistry().getBeanDefinitionCount() - countBefore; }本篇博文就先到这里吧，虽然还没有写完，但本篇博文实在有点长了，所以在下一篇博文中我们将继续分析IoC初始化过程，总结也就在下一篇写啦。
