Spring 源码阅读 04：BeanFactory 初始化

本篇要阅读的是 BeanFactory 初始化的部分，也就是 refresh 方法中的这一行方法调用：

// Tell the subclass to refresh the internal bean factory.
// 这里会调用模版方法，通过子类的实现，初始化 BeanFactory 并解析 XML 配置
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
 

这里调用了 obtainFreshBeanFactory 并得到了一个 ConfigurableListableBeanFactory 类型的 beanFactory。这个方法的作用是初始化 beanFactory ，还会解析 XML 中配置的 Bean。

我们先看源码：

 /**
* Tell the subclass to refresh the internal bean factory.
*  @return  the fresh BeanFactory instance
*  @see  #refreshBeanFactory()
*  @see  #getBeanFactory()
*/
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
   refreshBeanFactory();
   return getBeanFactory();
}
 

这个方法的源码很简单，调用了两个方法，并将第二个方法的结果返回。根据方法的名称可以看到，第一个方法用来刷新（或者初始化）beanFactory，第二个方法用来获取 beanFactory 并返回。

refreshBeanFactory 方法

我们先看 refreshBeanFactory 方法，具体实现过程可以在 AbstractRefreshableApplicationContext 类找到 ：

 /**
* This implementation performs an actual refresh of this context's underlying
* bean factory, shutting down the previous bean factory (if any) and
* initializing a fresh bean factory for the next phase of the context's lifecycle.
*/
@Override
protected final void refreshBeanFactory() throws BeansException {
   if (hasBeanFactory()) {
      destroyBeans();
      closeBeanFactory();
   }
   try {
      DefaultListableBeanFactory beanFactory = createBeanFactory();
      beanFactory.setSerializationId(getId());
      customizeBeanFactory(beanFactory);
      loadBeanDefinitions(beanFactory);
      synchronized (this.beanFactoryMonitor) {
         this.beanFactory = beanFactory;
      }
   }
   catch (IOException ex) {
      throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
   }
}
 

从方法的整体流程可以看出，不管当前是不是存在一个 BeanFactory ，这里都会创建一个新的，并进行初始化，我们来逐行分析代码。

销毁已有的 BeanFactory

一开始，会判断当前是否存在一个 BeanFactory，如果有的话，就销毁其中的 Bean，并关闭 BeanFactory。这部分逻辑对应方法体开头的 if 语句块。因为我们分析的是 Spring 容器第一次创建时候的流程，而且之前并没有 BeanFactory 创建的逻辑，所以，目前为止，并不存在一个 BeanFactory，if 语句中的逻辑不会被执行。

实例化新的 BeanFactory

接下来就是 try 语句块中的部分。

首先，执行了 createBeanFactory 方法，创建了一个 BeanFactory。这里的代码也很简单：

protected DefaultListableBeanFactory createBeanFactory() {
   return new DefaultListableBeanFactory(getInternalParentBeanFactory());
}
 

获取到 parent 后，调用构造方法，创建了一个 DefaultListableBeanFactory 的实例并返回。

DefaultListableBeanFactory 这个类型是第一次见到，我们可以大致看一下它的继承关系：

这里的接口实现关系错综复杂，可以先看看留个印象。值得一提的是，它的子类 XmlBeanFactory 是 Spring 中非常重要的一个类，是 Spring 的初级容器。如果使用 XML 配置文件来直接创建 BeanFactory 使用的就是 XmlBeanFactory ，不过现在这个类已经被标记了 @Deprecated。

言归正传，回到 refreshBeanFactory 方法中来。创建好 BeanFactory 后，通过 beanFactory.setSerializationId(getId()) 给了它一个 Id，序列化和反序列化的时候用。

对 BeanFactory 进行自定义

接下来，customizeBeanFactory(beanFactory) 执行了 ApplicationContext 对内部的 BeanFactory 的自定义。

protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
   if (this.allowBeanDefinitionOverriding != null) {
      beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
   }
   if (this.allowCircularReferences != null) {
      beanFactory.setAllowCircularReferences(this.allowCircularReferences);
   }
}
 

这里通过给 beanFactory 的成员变量赋值，做了两件事：

• 允许相同名称的 BeanDefinition 在容器中被覆盖
• 允许多个 Bean 之间存在循环依赖

这两点涉及到了 BeanDefinition 和 Bean 初始化的流程。

加载 BeanDefinition

最后一个方法调用，loadBeanDefinitions(beanFactory); 执行了 BeanDefinition 的加载。这里的实现逻辑可以在 AbstractXmlApplicationContext 中找到：

 /**
* Loads the bean definitions via an XmlBeanDefinitionReader.
*  @see  org.springframework.beans.factory.xml.XmlBeanDefinitionReader
*  @see  #initBeanDefinitionReader
*  @see  #loadBeanDefinitions
*/
@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
   // Create a new XmlBeanDefinitionReader for the given BeanFactory.
   XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
 
   // Configure the bean definition reader with this context's
   // resource loading environment.
   beanDefinitionReader.setEnvironment(this.getEnvironment());
   beanDefinitionReader.setResourceLoader(this);
   beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
 
   // Allow a subclass to provide custom initialization of the reader,
   // then proceed with actually loading the bean definitions.
   initBeanDefinitionReader(beanDefinitionReader);
   loadBeanDefinitions(beanDefinitionReader);
}
 

在这个方法中，首先创建了一个 XmlBeanDefinitionReader 的实例，并对其进行了配置。从它的名字可以知道，这个类用来读取 XML 中的 Bean 定义。

创建好之后，末尾调用了两个方法，我们先看 initBeanDefinitionReader 的源码：

protected void initBeanDefinitionReader(XmlBeanDefinitionReader reader) {
   reader.setValidating(this.validating);
}
 

方法名告诉我们方法的作用是对 XmlBeanDefinitionReader 进行初始化，这里只是设置了是否对 XML 文件进行验证（默认值是 true），其余什么也没干。我们还注意到，这个方法是 protected 修饰的，因此可以断定，这里是 Spring 留给我们的一个扩展点。我们可以通过重写这个方法，关闭 XML 验证、自定义 XML 的解析器，或者执行其他的一些设置。

最后将 beanDefinitionReader 作为参数，调用了另外一个 loadBeanDefinitions 方法。源码如下：

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
   Resource[] configResources = getConfigResources();
   if (configResources != null) {
      reader.loadBeanDefinitions(configResources);
   }
   String[] configLocations = getConfigLocations();
   if (configLocations != null) {
      reader.loadBeanDefinitions(configLocations);
   }
}
 

在这里，分别将 configResources 和 configLocations 作为参数，执行了 reader 的 loadBeanDefinitions 方法。不过，getConfigResources 这个方法直接返回了 null，因此，这里的逻辑就是，根据我们创建 ClassPathXmlApplicationContext 时提供的配置文件路径，进行 BeanDefinition 的加载。

~~这里 reader.loadBeanDefinitions 方法加载 BeanDefinition 的逻辑是现在 AbstractBeanDefinitionReader#loadBeanDefinitions(java.lang.String...) 方法中

完成初始化并赋值

方法的末尾，通过 this.beanFactory = beanFactory; 将之前创建并初始化好的 BeanFactory 赋值给 beanFactory 成员变量。

getBeanFactory 方法

最后我们在回到最开始的 obtainFreshBeanFactory 方法，看一下里面调用的第二个方法 getBeanFactory() 的源码，实现逻辑在 AbstractRefreshableApplicationContext 类中：

@Override
public final ConfigurableListableBeanFactory getBeanFactory() {
   synchronized (this.beanFactoryMonitor) {
      if (this.beanFactory == null) {
         throw new IllegalStateException("BeanFactory not initialized or already closed - " +
               "call 'refresh' before accessing beans via the ApplicationContext");
      }
      return this.beanFactory;
   }
}
 

这里其实就是把 refreshBeanFactory 方法创建并初始化的 BeanFactory 获取到并返回。