本篇要阅读的是 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 获取到并返回。
