资讯专栏INFORMATION COLUMN

上云采购季！| 2核2G4M爆款云服务器低至59元/年，更有多台、长期优惠，快来选购！

立即前往
首页/文章专栏/Spring解密 - XML解析 与 Bean注册

Spring解密 - XML解析 与 Bean注册

cncoder / 1897人阅读

摘要：解密是注册及加载的默认实现，整个模板中它可以称得上始祖。中是这样介绍的自动装配时忽略给定的依赖接口，比如通过其他方式解析上下文注册依赖，类似于通过进行的注入或者通过进行的注入。解析是资源文件读取解析注册的实现，要重点关注该类。

Spring是一个开源的设计层面框架，解决了业务逻辑层和其他各层的松耦合问题，将面向接口的编程思想贯穿整个系统应用，同时它也是Java工作中必备技能之一...

前言

由于记录的是Spring源码分析的过程，详细用法就不一一赘述了

核心代码

    org.springframework
    spring-context
    5.0.2.RELEASE
用法 
public class Application {

    public static void main(String[] args) {

        BeanDefinitionRegistry beanFactory = new DefaultListableBeanFactory();
        XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);
        ClassPathResource resource = new ClassPathResource("bean.xml");
        //整个资源加载的切入点。
        reader.loadBeanDefinitions(resource);
    }
}
解密

DefaultListableBeanFactory 是 Spring 注册及加载 bean 的默认实现，整个Spring Ioc模板中它可以称得上始祖。

跟踪DefaultListableBeanFactory，可以发现如下代码块，该设计的目的是什么？

public AbstractAutowireCapableBeanFactory() {
    super();
    ignoreDependencyInterface(BeanNameAware.class);
    ignoreDependencyInterface(BeanFactoryAware.class);
    ignoreDependencyInterface(BeanClassLoaderAware.class);
}

举例来说，当 A 中有属性 B 时，那么 Spring 在获取属性 A 时，如果发现属性 B 未实例化则会自动实例化属性 B，这也是Spring中提供的一个重要特性，在某些情况下 B 不会被初始化，比如实现了 BeanNameAware 接口。

Spring中是这样介绍的：自动装配时忽略给定的依赖接口，比如通过其他方式解析Application上下文注册依赖，类似于 BeanFactory 通过 BeanFactoryAware 进行的注入或者 ApplicationContext 通过 ApplicationContextAware 进行的注入。

资源管理

通过 Resource 接口来实现对 File、URL、Classpath 等资源的管理，Resource 负责对配置文件进行读取，即将配置文件封装为 Resource，然后交给 XmlBeanDefinitionReader 来处理。

XML 解析

XmlBeanDefinitionReader 是 Spring 资源文件读取、解析、注册的实现，要重点关注该类。

跟踪reader.loadBeanDefinitions(resource);，我们可以见到如下核心代码（剔除注释和抛出异常）

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
    try {
        InputStream inputStream = encodedResource.getResource().getInputStream();
        try {
            InputSource inputSource = new InputSource(inputStream);
            if (encodedResource.getEncoding() != null) {
                inputSource.setEncoding(encodedResource.getEncoding());
            }
            return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
        }
        finally {
            inputStream.close();
        }
    }
}

上文代码首先对 Resource 做了一次编码操作，目的就是担心 XML 存在编码问题

仔细观察InputSource inputSource = new InputSource(inputStream);，它的包名居然是org.xml.sax，所以我们可以得出Spring采用的是SAX解析，使用 InputSource 来决定如何读取 XML 文件。

最后将准备的数据通过参数传入到真正核心处理部分 doLoadBeanDefinitions(inputSource, encodedResource.getResource())

获取 Document

1.doLoadBeanDefinitions(inputSource, encodedResource.getResource());，省略若干catch和注释

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
        throws BeanDefinitionStoreException {
    try {
        Document doc = doLoadDocument(inputSource, resource);
        return registerBeanDefinitions(doc, resource);
    }
}

2.doLoadDocument(inputSource, resource);

protected Document doLoadDocument(InputSource inputSource, Resource resource) throws Exception {
    return this.documentLoader.loadDocument(inputSource, getEntityResolver(), this.errorHandler,
            getValidationModeForResource(resource), isNamespaceAware());
}

首先通过 getValidationModeForResource 获取 XML 文件的验证模式(DTD 或者 XSD)，可以自己设置验证方式，默认是开启 VALIDATION_AUTO 即自动获取验证模式的，通过 InputStream 读取 XML 文件，检查是否包含 DOCTYPE 单词，包含的话就是 DTD，否则返回 XSD。

常见的 XML 文件验证模式有:

public class XmlValidationModeDetector {
    /**
     * Indicates that DTD validation should be used (we found a "DOCTYPE" declaration).
     */
    public static final int VALIDATION_DTD = 2;

    /**
     * Indicates that XSD validation should be used (found no "DOCTYPE" declaration).
     */
    public static final int VALIDATION_XSD = 3;

    public int detectValidationMode(InputStream inputStream) throws IOException {
    
    }
}

在 this.documentLoader.loadDocument 方法中涉及到一个 EntityResolver 参数

public Document loadDocument(InputSource inputSource, EntityResolver entityResolver,
        ErrorHandler errorHandler, int validationMode, boolean namespaceAware) throws Exception {
}

何为 EntityResolver ? 官方解释: 如果 SAX 应用程序需要实现自定义处理外部实体，则必须实现此接口，并使用 setEntityResolver 方法向SAX 驱动器注册一个实例。也就是说，对于解析一个 xml，sax 首先会读取该 xml 文档上的声明，根据声明去寻找相应的 DTD 定义，以便对文档的进行验证，默认的寻找规则，(即:网络下载，通过 XML 声明的 DTD URI地址来下载 DTD的定义)，并进行认证，下载的过程是一个漫长的过程，而且当网络不可用时，这里会报错，就是因为相应的 dtd 没找到。

EntityResolver 的作用是项目本身就可以提供一个如何寻找 DTD 声明的方法，即由程序来实现寻找 DTD 的过程，这样就避免了通过网络来寻找相应的声明。

3.EntityResolver 接受两个参数:

public abstract InputSource resolveEntity (String publicId,String systemId)
        throws SAXException, IOException;

3.1 定义bean.xml文件，内容如下（XSD模式）

解析到如下两个参数:

publicId: null

systemId: http://www.springframework.or...

3.2 定义bean.xml文件，内容如下（DTD模式）

解析到如下两个参数:

publicId: -//SPRING//DTD BEAN 2.0//EN

systemId: http://www.springframework.or...

3.3 Spring 使用 DelegatingEntityResolver 来解析 EntityResolver

public class DelegatingEntityResolver {

    @Override
    @Nullable
    public InputSource resolveEntity(String publicId, @Nullable String systemId) throws SAXException, IOException {
        if (systemId != null) {
            if (systemId.endsWith(DTD_SUFFIX)) {
                return this.dtdResolver.resolveEntity(publicId, systemId);
            }
            else if (systemId.endsWith(XSD_SUFFIX)) {
                return this.schemaResolver.resolveEntity(publicId, systemId);
            }
        }
        return null;
    }

}

我们可以看到针对不同的模式，采用了不同的解析器

DTD： 采用 BeansDtdResolver 解析，直接截取 systemId 最后的 *.dtd（如：spring-beans.dtd），然后去当前路径下寻找

XSD： 采用 PluggableSchemaResolver 解析，默认加载 META-INF/Spring.schemas 文件下与 systemId 所对应的 XSD 文件

注册 Bean

看完解析XML校验后，继续跟踪代码，看 Spring 是如何根据 Document 注册 Bean 信息

public class XmlBeanDefinitionReader {

    public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
        // 创建DocumentReader
        BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
        // 记录统计前的 BeanDefinition 数
        int countBefore = getRegistry().getBeanDefinitionCount();
        // 注册 BeanDefinition
        documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
        // 记录本次加载 BeanDefinition 的个数
        return getRegistry().getBeanDefinitionCount() - countBefore;
    }
}

注册 Bean 的时候首先使用一个 BeanDefinitionParserDelegate 类来判断是否是默认命名空间，实现是通过判断 namespace uri 是否和默认的 uri 相等：

public class BeanDefinitionParserDelegate {

    public static final String BEANS_NAMESPACE_URI = "http://www.springframework.org/schema/beans";
    
    public boolean isDefaultNamespace(@Nullable String namespaceUri) {
        return (!StringUtils.hasLength(namespaceUri) || BEANS_NAMESPACE_URI.equals(namespaceUri));
    }

}

跟踪 documentReader.registerBeanDefinitions(doc, createReaderContext(resource));，其中 doc 是通过前面代码块中 loadDocument 转换出来的，这个方法主要目的就是提取出 root 节点（beans）

public class DefaultBeanDefinitionDocumentReader {

    @Override
    public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
        this.readerContext = readerContext;
        logger.debug("Loading bean definitions");
        Element root = doc.getDocumentElement();
        doRegisterBeanDefinitions(root);
    }

}

跟踪 doRegisterBeanDefinitions(root) ，我们将看到如下处理流程

protected void doRegisterBeanDefinitions(Element root) {

    // ...
    String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
    // ...
    
    // 空实现
    preProcessXml(root);
    parseBeanDefinitions(root, this.delegate);
    // 空实现
    postProcessXml(root);

    this.delegate = parent;
}

首先对 profile 解析（比较常见的玩法就是不同 profile 初始化的 bean 对象不同，实现多环境）

接下来的解析使用了模板方法模式，其中 preProcessXml 和 postProcessXml 都是空方法，为的就是方便之后的子类在解析前后进行一些处理。只需要覆写这两个方法即可。

解析并注册 BeanDefinition，该部分代码比较简单

public class DefaultBeanDefinitionDocumentReader {

    /**
     * 解析 root 节点下的其它节点 import", "alias", "bean".
     * @param root节点名称
     */
    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) {
        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);
        }
    }

    /**
     * 处理 Bean 标签，然后将其注册到注册表中去
     */
    protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
        BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
        if (bdHolder != null) {
            bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
            try {
                // Register the final decorated instance.
                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));
        }
    }
}

委托 BeanDefinitionParserDelegate 类的 parseBeanDefinitionElement 方法进行元素解析，返回 BeanDefinitionHolder 类型的实例 bdHolder（包含了配置文件的各个属性class、name、id、alias等）

当返回的 bdHolder 不为空的情况下，若默认标签的子节点存在自定义属性，则再次对自定义标签进行解析

解析完毕后，委托 BeanDefinitionReaderUtils.registerBeanDefinition();对 bdHolder 进行注册

发送注册事件，告知相关监听 Bean 已经注册成功了

总结

熬过几个无人知晓的秋冬春夏，撑过去一切都会顺着你想要的方向走...

说点什么

全文代码：https://gitee.com/battcn/battcn-spring-source/tree/master/Chapter1

个人QQ：1837307557

battcn开源群（适合新手）：391619659

微信公众号：battcn（欢迎调戏）

云服务器 GPU云服务器 spring bean 免费域名注册 与解析 xml?解析 码加密与解密

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/68190.html

相关文章

  • Spring解密 - 默认标签的解析

    Spring是一个开源的设计层面框架，解决了业务逻辑层和其他各层的松耦合问题，将面向接口的编程思想贯穿整个系统应用，同时它也是Java工作中必备技能之一... 前言 紧跟上篇 Spring解密 - XML解析 与 Bean注册 ，我们接着往下分析源码 解密 在 Spring 的 XML 配置里面有两大类声明，一个是默认的如 ，另一类就是自定义的如，两种标签的解析方式差异是非常大的。parseBe...

    snowLu 评论0 收藏0

  • Spring解密 - 自定义标签与解析

    摘要：自定义标签在讲解自定义标签解析之前，先看下如何自定义标签定义文件定义一个文件描述组件内容声明命名空间值得注意的是与可以是不存在，只要映射到指定就行了。 Spring是一个开源的设计层面框架，解决了业务逻辑层和其他各层的松耦合问题，将面向接口的编程思想贯穿整个系统应用，同时它也是Java工作中必备技能之一... 前言 在 上一节 Spring解密 - 默认标签的解析 中，重点分析了...

    Taste 评论0 收藏0

  • Spring解密 - Bean的加载流程

    摘要：判断调用哪个构造方法的过程会采用缓存机制，如果已经解析过则不需要重复解析而是从中的属性缓存的值去取，否则需再次解析。 Spring是一个开源的设计层面框架，解决了业务逻辑层和其他各层的松耦合问题，将面向接口的编程思想贯穿整个系统应用，同时它也是Java工作中必备技能之一... 前言 在 Spring解密 - XML解析 与 Bean注册 中，讲了 Bean的解析，本章将详细讲解Sp...

    bawn 评论0 收藏0

  • Spring专题之IOC源码分析

    摘要：前言以下源码基于版本解析。实现源码分析对于的实现，总结来说就是定位加载和注册。定位就是需要定位配置文件的位置，加载就是将配置文件加载进内存注册就是通过解析配置文件注册。下面我们从其中的一种使用的方式一步一步的分析的实现源码。 前言 以下源码基于Spring 5.0.2版本解析。 什么是IOC容器？ 容器，顾名思义可以用来容纳一切事物。我们平常所说的Spring IOC容器就是一个可以容...

    不知名网友 评论0 收藏0

  • Spring-IOC容器容器

    摘要：使用别名时，容器首先将别名元素所定义的别名注册到容器中。调用的方法向容器注册解析的通过对对象的解析和封装返回一个通过这个来注册对象当调用向容器注册解析的时，真正完成注册功能的是。 文章参考来自：https://www.cnblogs.com/ITtan... 文章代码来自 spring-boot 1.4.1 Release版本 Spring IoC容器对Bean定义资源的载入是从ref...

    BigTomato 评论0 收藏0

发表评论

登陆后可评论

0条评论

cncoder

男|高级讲师
我要私信

TA的文章

阅读更多
最新活动
阅读需要支付1元查看
<