Spring进阶- Spring IOC实现原理（二）IOC初始化流程

原创已于 2025-10-09 14:52:53 修改 · 1.1k 阅读

27 ·

CC 4.0 BY-SA版权

文章标签：

#spring #rpc #java

于 2025-10-03 00:24:23 首次发布

spring 专栏收录该内容

13 篇文章

订阅专栏

本文是 IOC 进阶第二篇。

本文的目标就是分析 Spring 如何实现将资源配置（以xml配置为例）通过加载，解析，生成 BeanDefination 并注册到IoC容器中的。

阅读源码初学者应该会很头大，给你们你做一个心理按摩。

Spring 源码代码量大，复杂，追源码 “迷路” 等问题非常让人苦恼，不过从以下两个角度入手学习源码会轻松很多。

熟悉 Spring IOC 启动的工作原理，做到心中有数，就明白下一步源码应该看哪里。
代码量大，找不到重点，跟着本文一步一步剖析重点。

源码本质上就是 java 代码，无非是初始化构造函数，对象之间的调用等，这些都是 java 语言的基本，不会难，重点要从顶层思维看 IOC 启动流程为何如此编写？本文做了大量阐述，帮助你从顶层视角看清 IOC 启动流程。通过阅读源码你会发现** IOC 容器在 Spring 中的技术实现不过就是一个 Java util 包的 Map 集合**。

引言

上文介绍了 IOC 进阶之体系结构，回顾核心组件，BeanFactory 、BeanRegistry ，继承 BeanFactory 的 ApplicationContext ， ApplicationContext 是一个很重要的组件，它实现了 **ResourceLoader **便具有加载配置的能力。

另外还有一个 BeanDefinitionReader 组件也很重要，ApplicationContext 会调用它解析 Bean 对象。 BeanDefinitionReader 与 BeanDefinition 之间是依赖关系，不要看名字脑部成继承或者实现哦~ BeanDefinitionReader 调用 BeanDefinition 创建一个 BeanDefinition 实例。

接下来以这几个组件开始，介绍 IOC 初始化流程，回顾上文最后一张图。

IOC 容器工作流程描述

我们从万恶之源 Application 启动类开始入手，在本系列文章的第一篇当中，有一个 HelloWorld 的例子中有个main 函数

 public static void main(String[] args) {
        // create and configure beans
        ApplicationContext context =
        new ClassPathXmlApplicationContext("daos.xml", "services.xml");

         // something...
    }

**new ClassPathXmlApplicationContext(configLocations)** 构造函数被调用，做了三件事

初始化 BeanFactory 和资源加载器 ResourceLoader
设置配置文件路径
refresh() 初始化容器

初始化容器是精彩之处，接着看如何初始化。

为容器刷新做准备工作，记录启动时间，初始化一些状态标志。
**初始化BeanFactory **: 创建并初始化 **BeanFactory**，这是容器的核心。
**准备 BeanFactory： **为 **BeanFactory** 设置一些标准的、通用的特性。比如：设置 **BeanFactory** 的类加载器。
**BeanFactory 后处理： **提供一个扩展点，允许子类在 **BeanFactory** 标准化准备完成后，对其进行个性化的定制
**调用 BeanFactory 后处理器: **在所有 Bean 实例化之前，对 **BeanFactory** 的元数据进行修改。
**注册 Bean 后处理器: **将所有 **BeanPostProcessor** 注册到 **BeanFactory** 中。
**初始化消息源: **为容器提供国际化（i18n）支持。
**初始化事件广播器:**为容器提供事件发布机制。
** 刷新onRefresh() : **留给子类在实例化 Bean 之前初始化一些特殊的、与上下文相关的资源。
**注册监听器:**将所有事件监听器注册到事件广播器中。
**完成 BeanFactory 初始化: **实例化所有剩余的、非懒加载的单例 Bean。这是 IoC 容器最核心、最耗时的步骤。
**完成刷新:**完成整个刷新过程，发布容器启动完成事件。

这是从源码的角度解释完整的 IOC 初始化流程，在本文目录的 4、初始化的主题流程中可看见源码。后面的源码剖析，是基于此流程选核心重点进行深入剖析，如：XML 加载 -> 转成 Document 对象 -> 转成 BeanDefinition 对象 -> 封装 BeanDefinitionHolder -> 注册 BeanDefinitionHolder 到容器中。

IOC 容器的工作原理

以 XML 为例，从 Spring 源码的角度探讨 XML 配置是如何加载到 IOC 容器中。

1、初始化的入口

在本系列文章的第一篇当中，有一个 HelloWorld 的例子演示了如何使用 XML 启动项目，其中 Spring 启动入口 main 函数关键代码是：

 public static void main(String[] args) {
        // create and configure beans
        ApplicationContext context =
        new ClassPathXmlApplicationContext("daos.xml", "services.xml");

         // something...
    }

ClassPathXmlApplicationContext 类的构造函数如下：

public ClassPathXmlApplicationContext(String... configLocations) throws BeansException {
    this(configLocations, true, (ApplicationContext)null);
}

public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, @Nullable ApplicationContext parent) throws BeansException {
    // 设置Bean资源加载器
    super(parent);

    // 设置配置路径
    this.setConfigLocations(configLocations);

    //  最终目标：IOC 容器刷新的入口 , 真正的精彩！
    if (refresh) {
        this.refresh();
    }
}

super(parent); 重点关注, 接下来深入挖掘它，它的作用之一是为 IOC 容器设置 Bean 资源加载器。

2、设置资源解析器和环境

挖掘 **super(parent) ， **调用父类容器 AbstractApplicationContext 的构造方法为容器设置好 Bean 资源加载器，代码如下：

public AbstractApplicationContext(@Nullable ApplicationContext parent) {
    // 默认构造函数初始化容器id, name, 状态 以及 资源解析器
    this();

    // 将父容器的Environment合并到当前容器
    this.setParent(parent);
}

重点这两个 this.

**1) ** this(); 通过 AbstractApplicationContext 默认构造函数初始化容器id, name, 状态以及资源解析器。

public AbstractApplicationContext() {
    this.logger = LogFactory.getLog(this.getClass());
    this.id = ObjectUtils.identityToString(this);
    this.displayName = ObjectUtils.identityToString(this);
    this.beanFactoryPostProcessors = new ArrayList();
    this.active = new AtomicBoolean();
    this.closed = new AtomicBoolean();
    this.startupShutdownMonitor = new Object();
    this.applicationStartup = ApplicationStartup.DEFAULT;
    this.applicationListeners = new LinkedHashSet();
    this.resourcePatternResolver = this.getResourcePatternResolver();
}
// Spring资源加载器
protected ResourcePatternResolver getResourcePatternResolver() {
    return new PathMatchingResourcePatternResolver(this);
}

2) this.setParent(parent); 方法将父容器的 Environment 合并到当前容器。上文我们有简单聊过父子容器，概念不难，理解成有多个容器， IOC 容器也有继承关系，父容器定义全局的、通用的 Bean。比如，数据库连接池、通用的安全服务、系统级别的配置等。子容器定义自己领域的Bean 。比如：各种 Service Bean 。

public void setParent(@Nullable ApplicationContext parent) {
    this.parent = parent;
    if (parent != null) { // 目前 if 条件不成立
        Environment parentEnvironment = parent.getEnvironment();
        if (parentEnvironment instanceof ConfigurableEnvironment) {
            this.getEnvironment().merge((ConfigurableEnvironment)parentEnvironment);
        }
    }
}

@Nullable 注解是可以为空，那么这里 parent 容器初始化自然是空的。

3、设置配置路径

现在目光回看** 1、初始化入口**，里面的 ClassPathXmlApplicationContext 的 super(parent) 加载资源搞定，继续 this.setConfigLocations(configLocations) ，看源码：

public void setConfigLocations(@Nullable String... locations) {
    if (locations != null) {
        Assert.noNullElements(locations, "Config locations must not be null");
        this.configLocations = new String[locations.length];

        for(int i = 0; i < locations.length; ++i) {
            // 解析配置路径
            this.configLocations[i] = this.resolvePath(locations[i]).trim();
        }
    } else {
        this.configLocations = null;
    }
}
protected String resolvePath(String path) {
    // 从上一步Environment中解析
    return this.getEnvironment().resolveRequiredPlaceholders(path);
}

setConfigLocations 方法通过调用其父类 AbstractRefreshableConfigApplicationContext 的方法进行对 Bean定义资源文件的定位。

进入到 ClassPathXmlApplicationContext 的初始化流程了。

4、初始化的主体流程

Spring IoC容器对Bean定义资源的载入是从refresh()函数开始的，refresh()是一个模板方法，refresh()方法的作用是：在创建IoC容器前，如果已经有容器存在，则需要把已有的容器销毁和关闭，以保证在refresh之后使用的是新建立起来的IoC容器。refresh的作用类似于对IoC容器的重启。

@Override
public void refresh() throws BeansException, IllegalStateException {
    // 加锁，防止并发刷新或关闭
    synchronized (this.startupShutdownMonitor) {
        // 1. 准备工作：设置启动时间、校验配置文件等
        prepareRefresh();

        // 2. 获取Bean工厂：创建并加载Bean定义到BeanFactory
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // 3. 准备Bean工厂：设置工厂的标准特性，如类加载器、后处理器等
        prepareBeanFactory(beanFactory);

        try {
            // 4. 后处理Bean工厂：提供给子类的扩展点，可对BeanFactory进行自定义
            postProcessBeanFactory(beanFactory);

            // 5. 调用工厂后处理器：执行BeanFactoryPostProcessor，修改Bean的定义信息
            invokeBeanFactoryPostProcessors(beanFactory);

            // 6. 注册Bean后处理器：注册BeanPostProcessor，用于拦截Bean的创建过程
            registerBeanPostProcessors(beanFactory);

            // 7. 初始化消息源：用于国际化(i18n)
            initMessageSource();

            // 8. 初始化事件广播器：用于发布事件
            initApplicationEventMulticaster();

            // 9. 刷新：提供给子类的扩展点，用于初始化特殊的Bean
            onRefresh();

            // 10. 注册监听器：将所有监听器Bean注册到事件广播器
            registerListeners();

            // 11. 实例化Bean：实例化所有剩余的非懒加载单例Bean
            finishBeanFactoryInitialization(beanFactory);

            // 12. 完成刷新：发布刷新完成事件，容器启动完毕
            finishRefresh();
        }
        catch (BeansException ex) {
            // 发生异常时，销毁已创建的Bean，并重置容器状态
            destroyBeans();
            cancelRefresh(ex);
            throw ex;
        }
        finally {
            // 重置Spring核心的公共缓存
            resetCommonCaches();
        }
    }
}

这个设计便是本文的主题，非常典型的资源类加载处理型的思路，头脑中要形成如下图的顶层思路，而不是只停留在流水式的方法上面。

不要将这段代码看成流水线一样的设计，如果上图你还是无法从顶层思路看待 IOC 容器初始化，那么下面将对顶层思路的四个重点进行分析，必然能帮到你。

1）模板方法设计模式，模板方法中使用典型的钩子方法。

**refresh()** 方法本身就是一个模板方法。它定义了 Spring 容器启动的标准、不可变的流程骨架。

这个骨架就像一个固定的生产线： **准备 -> 加载资源 -> 配置 -> 初始化核心组件 -> 实例化 -> 完成**

Spring 框架的设计者规定，任何一个 **ApplicationContext** 的实现（无论是基于 XML、注解还是配置类）都必须遵循这个骨架。这保证了所有 Spring 应用启动行为的一致性。

2）将具体的初始化加载方法插入到钩子方法之间

钩子方法是啥？

模板方法鱼总带我们在项目中写过，都不陌生吧，抽象类定义一套固定模板，并且部分的方法是抽象的，由子类按需实现，父类固定流程，子类按需变化。钩子方法便是父类的抽象方法。

钩子方法体现为**空实现或留给子类覆盖的方法，**其中 postProcessBeanFactory(beanFactory); 是一个典型的钩子，**AbstractApplicationContext** 不知道子类（如 **AnnotationConfigWebApplicationContext**）需要对 **BeanFactory** 做什么特殊定制。它就在这里“挖个坑”，让子类来“填坑”。子类可以覆盖此方法，添加自己特有的 **BeanPostProcessor** 或进行其他定制。

3）将初始化的阶段封装，让初始化过程有状态

这个设计让初始化过程不再是一个黑盒，而是一个可以被观察和记录的、分阶段的状态机。

看两行代码：

StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
...
StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
...
beanPostProcess.end();
...
contextRefresh.end();

**applicationStartup.start("...")**：这就像在流水线的每个关键工位前打卡，声明“现在进入了【XX阶段】”。
**step.end()**：在阶段完成后打卡下班，声明“【XX阶段】已完成”。

虽然就是一个普通的记录功能，类似于日志没啥技术含量，但它的设计精髓是：

可观测：使用监控工具清晰地看到容器启动卡在了哪个阶段，每个阶段耗时多久，极大地提升了问题排查的效率。
结构清晰：代码本身就是一份活的文档，明确地划分了“上下文刷新”、“Bean后置处理”等逻辑阶段，让阅读者能快速把握代码结构。

4）健壮性设计：**try/catch/finally** 的艺术

资源加载和初始化过程极易失败（如配置文件找不到、类定义错误、数据库连不上等）。一个不健壮的设计可能导致容器处于一个半死不活的中间状态，资源泄漏。

这里的 try/catch/finally 是运用之模范，鱼总带我们项目时也经常写，我们感受一下 Spring 小组和鱼总的 try/catch/finally 有多少相似之处。

**try 块：**包裹了所有核心的初始化步骤。这些步骤是原子性的——要么全部成功，要么全部失败。保证容器从一个初始状态，平滑过渡到一个完全就绪可用的状态。

**catch 块：**具有失败回滚的作用，非常重要，一旦try 的任何一步发生异常，它会立即执行清理和销毁操作，将容器内部状态标记为 “已取消”、“非活跃”，告诉外界这次启动失败，将异常抛出，通知启动的调用者发生了错误。

**finally 块：**无论 try 是成功还是失败，必定重置 Spring 核心的公共缓存

接下来从初始化的代码开始详解源码，上高速，高速入口代码：

         // 2. 获取Bean工厂：创建并加载Bean定义到BeanFactory
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

初始化BeanFactory之obtainFreshBeanFactory

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

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

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

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

初始化BeanFactory之loadBeanDefinitions

这一步加载 xml 文件啦，如： {“daos.xml”, “services.xml”}

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

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
    // 创建XmlBeanDefinitionReader，即创建Bean读取器，并通过回调设置到容器中去，容器使用该读取器读取Bean定义资源  
    XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

    // 配置上下文的环境，资源加载器、解析器
    beanDefinitionReader.setEnvironment(this.getEnvironment());
    beanDefinitionReader.setResourceLoader(this);
    beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this)); // 为Bean读取器设置SAX xml解析器

    // 允许子类自行初始化（比如校验机制），并提供真正的加载方法
    initBeanDefinitionReader(beanDefinitionReader); // 当Bean读取器读取Bean定义的Xml资源文件时，启用Xml的校验机制  
    loadBeanDefinitions(beanDefinitionReader);
}

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
    // 加载XML配置方式里的Bean定义的资源
    Resource[] configResources = getConfigResources();
    if (configResources != null) {
        reader.loadBeanDefinitions(configResources);
    }
    // 加载构造函数里配置的Bean配置文件，即{"aspects.xml", "daos.xml", "services.xml"}
    String[] configLocations = getConfigLocations();
    if (configLocations != null) {
        reader.loadBeanDefinitions(configLocations);
    }
}

可以看到在这里创建了一个 XmlBeanDefinitionReader 对象，它实现了 AbstractBeanDefinitionReader 、BeanDefinitionReader ，看一下 AbstractBeanDefinitionReader 可以了解读取 XML 的过程。

AbstractBeanDefinitionReader读取Bean定义资源

AbstractBeanDefinitionReader的loadBeanDefinitions方法源码如下：

这个类并不是加载 xml 的过程，它是创建了一个 Resource 对象，分派 Resource 对象给子类来加载 Bean.

@Override
public int loadBeanDefinitions(String location) throws BeanDefinitionStoreException {
    return loadBeanDefinitions(location, null);
}

public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDefinitionStoreException {
    ResourceLoader resourceLoader = getResourceLoader();
    if (resourceLoader == null) {
        throw new BeanDefinitionStoreException(
                "Cannot load bean definitions from location [" + location + "]: no ResourceLoader available");
    }

    // 模式匹配类型的解析器，这种方式是加载多个满足匹配条件的资源
    if (resourceLoader instanceof ResourcePatternResolver) {
        try {
            // 获取到要加载的资源
            Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
            int count = loadBeanDefinitions(resources); // 委派调用其子类XmlBeanDefinitionReader的方法，实现加载功能  
            if (actualResources != null) {
                Collections.addAll(actualResources, resources);
            }
            if (logger.isTraceEnabled()) {
                logger.trace("Loaded " + count + " bean definitions from location pattern [" + location + "]");
            }
            return count;
        }
        catch (IOException ex) {
            throw new BeanDefinitionStoreException(
                    "Could not resolve bean definition resource pattern [" + location + "]", ex);
        }
    }
    else {
        // 只能通过绝对路径URL加载单个资源.
        Resource resource = resourceLoader.getResource(location);
        int count = loadBeanDefinitions(resource);
        if (actualResources != null) {
            actualResources.add(resource);
        }
        if (logger.isTraceEnabled()) {
            logger.trace("Loaded " + count + " bean definitions from location [" + location + "]");
        }
        return count;
    }
}

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

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

XmlBeanDefinitionReader加载Bean定义资源

继续看子类XmlBeanDefinitionReader的loadBeanDefinitions(Resource …)方法看到代表bean文件的资源定义以后的载入过程。

通过源码分析，载入Bean定义资源文件的最后一步是将Bean定义资源转换为Document对象，该过程由documentLoader实现, documentLoader 内部真正进行 IO 读取。

/**
    * 本质上是加载XML配置的Bean。
    * @param inputSource the SAX InputSource to read from
    * @param resource the resource descriptor for the XML file
    */
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
        throws BeanDefinitionStoreException {

    try {
        // doLoadDocument 方法内部是真正进行 IO 读取 XML 
        Document doc = doLoadDocument(inputSource, resource); // 将Bean定义资源转换成Document对象
        int count = registerBeanDefinitions(doc, resource); // 对 Bean 定义的解析过程
        if (logger.isDebugEnabled()) {
            logger.debug("Loaded " + count + " bean definitions from " + resource);
        }
        return count;
    }
    catch (BeanDefinitionStoreException ex) {
        throw ex;
    }
    catch (SAXParseException ex) {
        throw new XmlBeanDefinitionStoreException(resource.getDescription(),
                "Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);
    }
    catch (SAXException ex) {
        throw new XmlBeanDefinitionStoreException(resource.getDescription(),
                "XML document from " + resource + " is invalid", ex);
    }
    catch (ParserConfigurationException ex) {
        throw new BeanDefinitionStoreException(resource.getDescription(),
                "Parser configuration exception parsing XML from " + resource, ex);
    }
    catch (IOException ex) {
        throw new BeanDefinitionStoreException(resource.getDescription(),
                "IOException parsing XML document from " + resource, ex);
    }
    catch (Throwable ex) {
        throw new BeanDefinitionStoreException(resource.getDescription(),
                "Unexpected exception parsing XML document from " + resource, ex);
    }
}

// 使用配置的DocumentLoader加载XML定义文件为Document.
protected Document doLoadDocument(InputSource inputSource, Resource resource) throws Exception {
    return this.documentLoader.loadDocument(inputSource, getEntityResolver(), this.errorHandler,
            getValidationModeForResource(resource), isNamespaceAware());
}

DocumentLoader将Bean定义资源转换为Document对象

这一步是将 XML 文件的符号转换成 Document 对象，这一步的内部有两步，一解析 XML, 二解析 Document , 然后才是转换。

DocumentLoader **将 Bean定义资源 **转换成 **Document对象 **的源码如下：

// 使用标准的JAXP将载入的Bean定义资源转换成document对象
@Override
public Document loadDocument(InputSource inputSource, EntityResolver entityResolver,
        ErrorHandler errorHandler, int validationMode, boolean namespaceAware) throws Exception {

    // 创建文件解析器工厂
    DocumentBuilderFactory factory = createDocumentBuilderFactory(validationMode, namespaceAware);
    if (logger.isTraceEnabled()) {
        logger.trace("Using JAXP provider [" + factory.getClass().getName() + "]");
    }
    // 创建文档解析器
    DocumentBuilder builder = createDocumentBuilder(factory, entityResolver, errorHandler);
    return builder.parse(inputSource); // 解析
}

protected DocumentBuilderFactory createDocumentBuilderFactory(int validationMode, boolean namespaceAware)
        throws ParserConfigurationException {

    DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    factory.setNamespaceAware(namespaceAware);

    // 设置解析XML的校验
    if (validationMode != XmlValidationModeDetector.VALIDATION_NONE) {
        factory.setValidating(true);
        if (validationMode == XmlValidationModeDetector.VALIDATION_XSD) {
            // Enforce namespace aware for XSD...
            factory.setNamespaceAware(true);
            try {
                factory.setAttribute(SCHEMA_LANGUAGE_ATTRIBUTE, XSD_SCHEMA_LANGUAGE);
            }
            catch (IllegalArgumentException ex) {
                ParserConfigurationException pcex = new ParserConfigurationException(
                        "Unable to validate using XSD: Your JAXP provider [" + factory +
                        "] does not support XML Schema. Are you running on Java 1.4 with Apache Crimson? " +
                        "Upgrade to Apache Xerces (or Java 1.5) for full XSD support.");
                pcex.initCause(ex);
                throw pcex;
            }
        }
    }

    return factory;
}

该解析过程调用JavaEE标准的JAXP标准进行处理。

至此Spring IoC容器根据定位的Bean定义资源文件，将其加载读入并转换成为Document对象过程完成。

接下来我们要继续分析Spring IoC容器将载入的Bean定义资源文件转换为Document对象之后，是如何将其解析为Spring IoC管理的Bean对象并将其注册到容器中的。

XmlBeanDefinitionReader解析载入的 Bean 定义资源文件

这一步是对 XML 文件解析。

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

// 按照Spring的Bean语义要求将Bean定义资源解析并转换为容器内部数据结构 
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
    BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
    int countBefore = getRegistry().getBeanDefinitionCount();
    // 解析过程入口，这里使用了委派模式，具体的解析实现过程有实现类DefaultBeanDefinitionDocumentReader完成  
    documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
    return getRegistry().getBeanDefinitionCount() - countBefore;  // 返回此次解析了多少个对象
}

// 创建BeanDefinitionDocumentReader对象，解析Document对象  
protected BeanDefinitionDocumentReader createBeanDefinitionDocumentReader() {
    return BeanUtils.instantiateClass(this.documentReaderClass);
}

/**
    * Create the {@link XmlReaderContext} to pass over to the document reader.
    */
public XmlReaderContext createReaderContext(Resource resource) {
    return new XmlReaderContext(resource, this.problemReporter, this.eventListener,
            this.sourceExtractor, this, getNamespaceHandlerResolver());
}

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

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

Document对象解析的过程是在接口BeanDefinitionDocumentReader的实现类DefaultBeanDefinitionDocumentReader 中实现的。

DefaultBeanDefinitionDocumentReader对Bean定义的Document对象解析

对 Document 对象进行解析，转换成 Document 对象。

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

@Override
public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
    this.readerContext = readerContext;
    doRegisterBeanDefinitions(doc.getDocumentElement());
}

// 注册<beans/>配置的Beans
@SuppressWarnings("deprecation")  // for Environment.acceptsProfiles(String...)
protected void doRegisterBeanDefinitions(Element root) {
    // Any nested <beans> elements will cause recursion in this method. In
    // order to propagate and preserve <beans> default-* attributes correctly,
    // keep track of the current (parent) delegate, which may be null. Create
    // the new (child) delegate with a reference to the parent for fallback purposes,
    // then ultimately reset this.delegate back to its original (parent) reference.
    // this behavior emulates a stack of delegates without actually necessitating one.
    BeanDefinitionParserDelegate parent = this.delegate;
    this.delegate = createDelegate(getReaderContext(), root, parent);

    if (this.delegate.isDefaultNamespace(root)) {
        String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
        if (StringUtils.hasText(profileSpec)) {
            String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
                    profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
            // We cannot use Profiles.of(...) since profile expressions are not supported
            // in XML config. See SPR-12458 for details.
            if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Skipped XML bean definition file due to specified profiles [" + profileSpec +
                            "] not matching: " + getReaderContext().getResource());
                }
                return;
            }
        }
    }

    preProcessXml(root);
    parseBeanDefinitions(root, this.delegate); // 从Document的根元素开始进行Bean定义的Document对象  
    postProcessXml(root);

    this.delegate = parent;
}

BeanDefinitionParserDelegate解析Bean定义资源文件生成BeanDefinition

将 Ducument 对象转换为 BeanDefinition 对象。

/**
    * Parse the elements at the root level in the document:
    * "import", "alias", "bean".
    * @param root the DOM root element of the document
    */
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
    if (delegate.isDefaultNamespace(root)) {
        NodeList nl = root.getChildNodes();
        for (int i = 0; i < nl.getLength(); i++) {
            Node node = nl.item(i);
            if (node instanceof Element) {
                Element ele = (Element) node;
                if (delegate.isDefaultNamespace(ele)) {
                    parseDefaultElement(ele, delegate);
                }
                else {
                    delegate.parseCustomElement(ele);
                }
            }
        }
    }
    else {
        delegate.parseCustomElement(root);
    }
}

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
      
    // 如果元素节点是<Import>导入元素，进行导入解析
    if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
        importBeanDefinitionResource(ele);
    }
    // 如果元素节点是<Alias>别名元素，进行别名解析 
    else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
        processAliasRegistration(ele);
    }
    // 如果元素节点<Bean>元素, 按照Spring的Bean规则解析元素  
    else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
        processBeanDefinition(ele, delegate);
    }
    // 如果元素节点<Beans>元素，即它是嵌套类型的
    else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
        // 递归解析
        doRegisterBeanDefinitions(ele);
    }
}

然后是把 BeanDefinition 封装成 BeanDefinitionHolder 的源码。BeanDefinitionHolder 是一个信息更丰富的“工作载体”

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
    BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
    if (bdHolder != null) {
        bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
        try {
            // 注册最终的装饰实例
            BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
        }
        catch (BeanDefinitionStoreException ex) {
            getReaderContext().error("Failed to register bean definition with name '" +
                    bdHolder.getBeanName() + "'", ele, ex);
        }
        // Send registration event.
        getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
    }
}

得到一个 BeanDefinitionHolder 对象就代表 Bean 已经正式解析好了，可以被注入到容器。

解析过后的BeanDefinition在IoC容器中的注册

这一步是要把 BeanDefinitionHolder 对象注册到容器中。

调用BeanDefinitionReaderUtils的registerBeanDefinition方法向IoC容器注册解析的Bean，BeanDefinitionReaderUtils的注册的源码如下：

// 通过BeanDefinitionRegistry将BeanDefinitionHolder注册到BeanFactory
public static void registerBeanDefinition(
        BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
        throws BeanDefinitionStoreException {

    // Register bean definition under primary name.
    String beanName = definitionHolder.getBeanName();
    registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

    // Register aliases for bean name, if any.
    String[] aliases = definitionHolder.getAliases();
    if (aliases != null) {
        for (String alias : aliases) {
            registry.registerAlias(beanName, alias);
        }
    }
}

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

DefaultListableBeanFactory向IoC容器注册解析后的BeanDefinition

这里能看到 Spirng IOC 容器技术实现的真面目，本质上是一个 Map<String, BeanDefinition> .

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

/** Map of bean definition objects, keyed by bean name. */
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

/** Map from bean name to merged BeanDefinitionHolder. */
private final Map<String, BeanDefinitionHolder> mergedBeanDefinitionHolders = new ConcurrentHashMap<>(256);


@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
        throws BeanDefinitionStoreException {

    Assert.hasText(beanName, "Bean name must not be empty");
    Assert.notNull(beanDefinition, "BeanDefinition must not be null");

    if (beanDefinition instanceof AbstractBeanDefinition) {
        try {
            ((AbstractBeanDefinition) beanDefinition).validate();
        }
        catch (BeanDefinitionValidationException ex) {
            throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
                    "Validation of bean definition failed", ex);
        }
    }

    BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
    // 如果已经注册
    if (existingDefinition != null) {
        // 检查是否可以覆盖
        if (!isAllowBeanDefinitionOverriding()) {
            throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
        }
        else if (existingDefinition.getRole() < beanDefinition.getRole()) {
            // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
            if (logger.isInfoEnabled()) {
                logger.info("Overriding user-defined bean definition for bean '" + beanName +
                        "' with a framework-generated bean definition: replacing [" +
                        existingDefinition + "] with [" + beanDefinition + "]");
            }
        }
        else if (!beanDefinition.equals(existingDefinition)) {
            if (logger.isDebugEnabled()) {
                logger.debug("Overriding bean definition for bean '" + beanName +
                        "' with a different definition: replacing [" + existingDefinition +
                        "] with [" + beanDefinition + "]");
            }
        }
        else {
            if (logger.isTraceEnabled()) {
                logger.trace("Overriding bean definition for bean '" + beanName +
                        "' with an equivalent definition: replacing [" + existingDefinition +
                        "] with [" + beanDefinition + "]");
            }
        }
        // 覆盖
        this.beanDefinitionMap.put(beanName, beanDefinition);
    }
    else {
        if (hasBeanCreationStarted()) {
            // Cannot modify startup-time collection elements anymore (for stable iteration)
            synchronized (this.beanDefinitionMap) {
                this.beanDefinitionMap.put(beanName, beanDefinition);
                List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
                updatedDefinitions.addAll(this.beanDefinitionNames);
                updatedDefinitions.add(beanName);
                this.beanDefinitionNames = updatedDefinitions;
                removeManualSingletonName(beanName);
            }
        }
        else {
            // Still in startup registration phase
            this.beanDefinitionMap.put(beanName, beanDefinition);
            this.beanDefinitionNames.add(beanName);
            removeManualSingletonName(beanName);
        }
        //重置所有已经注册过的BeanDefinition的缓存  
        this.frozenBeanDefinitionNames = null;
    }

    if (existingDefinition != null || containsSingleton(beanName)) {
        resetBeanDefinition(beanName);
    }
    else if (isConfigurationFrozen()) {
        clearByTypeCache();
    }
}