02-Spring配置文件加载

获取IOC容器

加载、解析xml文件，形成GenericBeanDefinition，供后续实例化剩下的所有 Bean 使用。

obtainFreshBeanFactory()

获取IOC容器

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
    // 初始化BeanFactory,并进行XML文件读取，并将得到的BeanFactory记录在当前实体的属性中
    refreshBeanFactory();
    // 返回当前实体的beanFactory属性
    return getBeanFactory();
}

refreshBeanFactory()

刷新IOC容器，此类是一个抽象类，在前面初始化的对象，不同，此类方法执行的不同。这里主要执行的是 AbstractRefreshableApplicationContext中实现的方法。

protected final void refreshBeanFactory() throws BeansException {
    // 如果存在beanFactory，则销毁beanFactory
    if (hasBeanFactory()) {
        destroyBeans();
        closeBeanFactory();
    }
    try {
        // 创建DefaultListableBeanFactory对象
        DefaultListableBeanFactory beanFactory = createBeanFactory();
        // 为了序列化指定id，可以从id反序列化到beanFactory对象
        beanFactory.setSerializationId(getId());
        // 定制beanFactory，设置相关属性，包括是否允许覆盖同名称的不同定义的对象以及循环依赖
        customizeBeanFactory(beanFactory);
        // 初始化documentReader,并进行XML文件读取及解析,默认命名空间的解析，自定义标签的解析
        loadBeanDefinitions(beanFactory);
        this.beanFactory = beanFactory;
    }
    catch (IOException ex) {
        throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
    }
}

refreshBeanFactory() 方法的另一个实现是在 GenericApplicationContext 中，Spring Boot 的纯注解就是调用这个方法，因为在 AnnotationConfigServletWebServerApplicationContext 的时候就将 IOC容器已经创建完毕了。

protected final void refreshBeanFactory() throws IllegalStateException {
    if (!this.refreshed.compareAndSet(false, true)) {
        throw new IllegalStateException(
            "GenericApplicationContext does not support multiple refresh attempts: just call 'refresh' once");
    }
    this.beanFactory.setSerializationId(getId());
}

createBeanFactory()

在 createBeanFactory() 的方法中 new DefaultListableBeanFactory()，往其父类构造方法中能够找到这样一段代码，是 AbstractAutowireCapableBeanFactory 的构造方法。

public AbstractAutowireCapableBeanFactory() {
    super();
    // 忽略要依赖的接口，此处忽略的接口会在后面创建 Bean  的时候，判断是否进行回调。
    ignoreDependencyInterface(BeanNameAware.class);
    ignoreDependencyInterface(BeanFactoryAware.class);
    ignoreDependencyInterface(BeanClassLoaderAware.class);
}

customizeBeanFactory()

在 IoC 容器中设置的两个属性，在后面会使用到这两个参数。

protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
    // 如果属性allowBeanDefinitionOverriding不为空，设置给beanFactory对象相应属性，是否允许覆盖同名称的不同定义的对象
    if (this.allowBeanDefinitionOverriding != null) {
        beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
    }
    // 如果属性allowCircularReferences不为空，设置给beanFactory对象相应属性，是否允许bean之间存在循环依赖
    if (this.allowCircularReferences != null) {
        beanFactory.setAllowCircularReferences(this.allowCircularReferences);
    }
}

loadBeanDefinitions(beanFactory)

这个方法有很多的重载方法，很容易迷，在这里简单说一下，loadBeanDefinition 方法主要有加载 String 路径形式的，Resource 资源形式的，还有数组类型的，但是数组类型最终会调回单个的形式，String 路径形式的，会封装成 Resource 资源的形式来进行加载。在此方法中会通过创建一个 BeanDefinitionReader 形式的读取器，来对资源文件进行，将解析后的资源形成 BeanDefinition，供后续创建 Bean 对象使用。

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
    // Create a new XmlBeanDefinitionReader for the given BeanFactory.
    // 创建一个xml的beanDefinitionReader，并通过回调设置到beanFactory中
    XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

    // Configure the bean definition reader with this context's
    // resource loading environment.
    // 给reader对象设置环境对象
    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.
    //  初始化beanDefinitionReader对象，此处设置配置文件是否要进行验证
    initBeanDefinitionReader(beanDefinitionReader);
    // 开始完成beanDefinition的加载
    loadBeanDefinitions(beanDefinitionReader);
}

getConfigLocations()里面的数据来源于前面 setConfigLocations();

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
    // 以Resource的方式获得配置文件的资源位置
    Resource[] configResources = getConfigResources();
    if (configResources != null) {
        reader.loadBeanDefinitions(configResources);
    }
    // 以String的形式获得配置文件的位置
    String[] configLocations = getConfigLocations();
    if (configLocations != null) {
        reader.loadBeanDefinitions(configLocations);
    }
}

reader.loadBeanDefinitions()

经过一系列的重载方法的处理，最终会调用 doLoadBeanDefinitions(inputSource, encodedResource.getResource()) 对其资源文件进行处理，当然前面有一步涉及到将 String 类型的文件名转换为 Resource，然后进行处理

/** 转换的核心方法，这个地方的资源解析器来源于前面的构造方法 */
Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
int count = loadBeanDefinitions(resources);

异常信息给去掉了

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
    throws BeanDefinitionStoreException {

    try {
        // 此处获取xml文件的document对象，这个解析过程是由documentLoader完成的,从String[] -string-Resource[]- resource,最终开始将resource读取成一个document文档，根据文档的节点信息封装成一个个的 BeanDefinition 对象
        Document doc = doLoadDocument(inputSource, resource);
        int count = registerBeanDefinitions(doc, resource);
        if (logger.isDebugEnabled()) {
            logger.debug("Loaded " + count + " bean definitions from " + resource);
        }
        return count;
    }
}

registerBeanDefinitions(doc, resource)

具体的解析，注册逻辑，doLoadDocument 主要将 xml 对象解析封装为 Document 对象，这里主要说明 BeanDefinition 具体的解析逻辑。此处还涉及到后续自定义标签解析的一部分工作，在 createReaderContext(resource)方法中会创建 DefaultNamespaceHandlerResolver，此方法会在后续的时候加载 META-INF/spring.handlers 中的 uri 和解析器的一个对应关系。

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
   // 对xml的beanDefinition进行解析
   BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
   int countBefore = getRegistry().getBeanDefinitionCount();
   // 完成具体的解析过程
   documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
   return getRegistry().getBeanDefinitionCount() - countBefore;
}

调用的是默认的 DefaultBeanDefinitionDocumentReader#registerBeanDefinition

doRegisterBeanDefinitions()

具体的注册解析逻辑

protected void doRegisterBeanDefinitions(Element root) {
    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;
            }
        }
    }

    /** 处理 xml 之前，可以对其进行扩展 */
    preProcessXml(root);
    /** 解析 xml 形成 BeanDefinition */
    parseBeanDefinitions(root, this.delegate);
    /** 处理 xml 之后，可以对其进行扩展 */
    postProcessXml(root);

    this.delegate = parent;
}

parseBeanDefinitions

里面包含默认的 bean 标签的解析和其余自定义的标签的处理，这里暂时不对自定义标签的解析其进行具体的解析，在随后的一篇文章中说明。

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);
    }
}

parseDefaultElement()

解析默认的标签，包含 import，alias、beans、bean等标签的解析，注意： beans标签的解析会是一个递归的过程，又会返回去调用 doRegisterBeanDefinitions(ele) 方法。

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
    if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
        importBeanDefinitionResource(ele);
    }
    else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
        processAliasRegistration(ele);
    }
    else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
        processBeanDefinition(ele, delegate);
    }
    else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
        // recurse
        doRegisterBeanDefinitions(ele);
    }
}

processBeanDefinition(ele, delegate)

处理 BeanDefinition，主要是用 BeanDefinitionParserDelegate 策略对其进行解析，解析之后形成 BeanDefinitionHolder。

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
    // beanDefinitionHolder是beanDefinition对象的封装类，封装了BeanDefinition，bean的名字和别名，用它来完成向IOC容器的注册
    // 得到这个beanDefinitionHolder就意味着beandefinition是通过BeanDefinitionParserDelegate对xml元素的信息按照spring的bean规则进行解析得到的
    BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
    if (bdHolder != null) {
        bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
        try {
            // Register the final decorated instance.
            // 向ioc容器注册解析得到的beandefinition的地方
            BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
        }
        catch (BeanDefinitionStoreException ex) {
            getReaderContext().error("Failed to register bean definition with name '" +
                                     bdHolder.getBeanName() + "'", ele, ex);
        }
        // Send registration event.
        // 在beandefinition向ioc容器注册完成之后，发送消息
        getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
    }
}

registerBeanDefinition()

将得到的 BeanDefinition 注册到 IOC 中。

public static void registerBeanDefinition(
    BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
    throws BeanDefinitionStoreException {

    // Register bean definition under primary name.
    // 使用beanName做唯一标识注册
    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);
        }
    }
}

registerBeanDefinition

方法存在于 DefaultListableBeanFactory 类中，主要存放在两个地方，一个为 beanDefinitionMap，beanName 为 key，BeanDefinition 为 value，beanDefinitionNames 中存放所有的 Bean 名称，在后续实例化所有剩下的 bean 中会使用，注意：beanDefinitionNames 中存放的名称是有顺序的。

至此 解析形成的 xml 已经注册到 IOC 中。

private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

private volatile List<String> beanDefinitionNames = new ArrayList<>(256);