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

巴特西

02-Spring配置文件加载

获取IOC容器

obtainFreshBeanFactory()

refreshBeanFactory()

createBeanFactory()

customizeBeanFactory()

loadBeanDefinitions(beanFactory)

reader.loadBeanDefinitions()

registerBeanDefinitions(doc, resource)

doRegisterBeanDefinitions()

parseBeanDefinitions

parseDefaultElement()

processBeanDefinition(ele, delegate)

registerBeanDefinition()

registerBeanDefinition

最新文章

热门文章