spring 源码分析(1)-xml文件解析

本文涉及的产品
公共DNS(含HTTPDNS解析),每月1000万次HTTP解析
云解析 DNS,旗舰版 1个月
全局流量管理 GTM,标准版 1个月
简介:

我们在最开始接触spring的时候,看到不少书spring入门的例子如下

ApplicationContext atx = new ClassPathXmlApplicationContext("application.xml");
atx.getBean("benefitService");

上面这个例子第一行是表示如何初始化一个spring 容器,第二表示如何从一个已经初始化后的spring容器中按bean id得到这个bean, 绝大部分spring应用中,bean都是按业务模板和层次分别配置在不同的xml文件中, spring容器根据配置的xml文件名路径去分别解析这些xml 配置文件,生成相应的BeanDefinition 实例,一个bean对应一个BeanDefinition, 解析完成bean 的xml配置文件之后,spring容器就开始初始bean,大概的过程如下:
image.png
这篇文章主要分析第一个阶段,即xml配置文件 ---->BeanDefinition这个过程,首先根据IDE工具看一下ClassPathXmlApplicationContext 这个类的继承关系:
image.png
通过这个继续关系,发现ClassPathXmlApplicationContext也是间接实现了ResourceLoader这个接口, ResourceLoader的实现类主要用于根据给定的资源文件地址返回对应的Resource,在本例中,这个资源文件就是application.xml;
接着往下看

public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
    this(new String[] {configLocation}, true, null);
}
public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, 
                     ApplicationContext parent)  throws BeansException {
    super(parent);
    setConfigLocations(configLocations);
    if (refresh) {
        refresh();
    }
}

代码到了含有三个参数的构造方法,主要有三个步骤

super(parent)

这个步骤主要是调父类的构造器初始化容器的parent对象,这示例中,parent这个参数为空,其次是初始化资源模式解析器resourcePatternResolver,是一个实现了ResourceLoader的类,源码如下 :

public AbstractApplicationContext(ApplicationContext parent) {
        this.parent = parent;
        this.resourcePatternResolver = getResourcePatternResolver();
}
protected ResourcePatternResolver getResourcePatternResolver() {
        return new PathMatchingResourcePatternResolver(this);
}
public PathMatchingResourcePatternResolver(ResourceLoader resourceLoader) {
        Assert.notNull(resourceLoader, "ResourceLoader must not be null");
        this.resourceLoader = resourceLoader;
}

setConfigLocations(configLocations)

这行代码,主要就是初始化configLocations这个数组字段,源码如下:

private String[] configLocations;
public void setConfigLocations(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] = resolvePath(locations[i]).trim();
        }
    }
    else {
        this.configLocations = null;
    }
}

其中resolvePath主要解析并填充资源路径中的一些系统占位符,
如开始符:${,
结束符: }
分割符: :

refresh()

前面两步基本上都是容器本身的设置初始化,这个步骤才是spring 容器解析,创建初始化bean的关键步骤,点时去,我们发现这个方法长,只分析xml解析的过程,其它的在这里不一 一细说,在refresh方法中,第二代码是这样的:

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

直接进入org.springframework.context.support.AbstractRefreshableApplicationContext.refreshBeanFactory()这个方法,看一下这个方法体:

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

这个方法的大意是这样的:

  1. 先判断有没有beanFactory, 如果已经存在beanFactory,就先销毁beanFactory中所有的bean,再关闭这个beanFactory
  2. 创建一个DefaultListableBeanFactory 类型实例的beanFactory;
  3. 设置beanFactory的id,其中id是根据类名生成的,具体代码是:

     obj.getClass().getName() + "@" + getIdentityHexString(obj)
  4. 定置化beanFactory, 主要是设置: Bean是否需求覆盖重写,是否允bean循环引用,参数自动发现和注释字段bean匹配解析,例如Autowired注解;
    5.解析xml文档,并生成BeanDefinition对象实例集合;

重点看第5个步骤,即loadBeanDefinitions(beanFactory)这行代码,根据继承关系,直接进入org.springframework.web.context.support.XmlWebApplicationContext.loadBeanDefinitions(DefaultListableBeanFactory)这个方法

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

这个方法的逻辑也很清晰

  1. 创建一个XmlBeanDefinitionReader 对象,这个类主要定义读取的Document,并注册BeanDefinition的功能;
  2. 设置beanDefinitionReader 对象的ResourceLoader,即ClassPathXmlApplicationContext类对象;
  3. 设置beanDefinitionReader 对象的解析对象:ResourceEntityResolver
  4. 初始化beanDefinitionReader 对象,在spring框架中,这个方法为空,是一个重写spring框架的扩展点;
protected void initBeanDefinitionReader(XmlBeanDefinitionReader beanDefinitionReader) {}
  1. 正式解析xml文件,并生成BeanDefinitions, 方法体如下:
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws IOException {
    String[] configLocations = getConfigLocations();
    if (configLocations != null) {
        for (String configLocation : configLocations) {
            reader.loadBeanDefinitions(configLocation);
        }
    }
}

针对每个资源文件,重点看下面这两行代码:

Resource resource = resourceLoader.getResource(location);
int loadCount = loadBeanDefinitions(resource);

第一行代码主是获取路径中以classpath:开头的xml文件,当然也有很多其它前缀开头的资源,org.springframework.util.ResourceUtils 这个类中有详细的说明
第二主要是生成加载BeanDefinitions

public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
    return loadBeanDefinitions(new EncodedResource(resource));
}

前面都是一些准备过程,接下来,到了真正执行loadBeanDefinitions
image.png
image.png

  1. getValidationModeForResource这个方法主要是获取xml文件的验证模式,主要有DTD和XSD两种验证模式,这两种验证模式,spring都支持,方法源码如下:
    image.png

DTD模式示例:
image.png
XSD模式示例:
image.png

  1. 加载xml,并得到转换成对应的Document实例
  2. 解析并注册xml文件定义相关的bean;
    重点看一下步骤3:

相关的方法源码如下:

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
    // 使用 DefaultBeanDefinitionDocumentReader实例化BeanDefinitionDocumentReader对象
    BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
        // 记录统计前已经加载的BeanDefinition数量
    int countBefore = getRegistry().getBeanDefinitionCount();
         // 加载并注册bean
    documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
        // 记录本次加载的 BeanDefinition数量
    return getRegistry().getBeanDefinitionCount() - countBefore;
}

重点分析 documentReader.registerBeanDefinitions(doc, createReaderContext(resource))这行代

public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
        this.readerContext = readerContext;

        logger.debug("Loading bean definitions");
        Element root = doc.getDocumentElement();

        BeanDefinitionParserDelegate delegate = createHelper(readerContext, root);

        preProcessXml(root);
        parseBeanDefinitions(root, delegate);
        postProcessXml(root);
}

registerBeanDefinitions这个方法的逻辑也比较清晰

  1. 赋值readerContext
  2. 获取xml对象加载包装后对应Document对象
  3. 创建解析器 BeanDefinitionParserDelegate 类型的对象实例:delegate
  4. 处理xml文件的前置处理,默认为空,这是一个扩展点;
  5. 解析xml文件,并注册到spring容器中
  6. 处理xml文件的后轩处理,默认为空,这也是一个扩展点;
    重点看一下parseBeanDefinitions这个方法,方法实现源码如下:
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)) {
                                        //默认标签bean的解析
                                        //<bean id="benefitService" class="com.tmall.xxx">
                    parseDefaultElement(ele, delegate);
                } else {
                                       //自定义标签bean的解析
                                        <tx:annotation-driven />
                                       <dubbo:service  timeout="3000" interface="com.tmall.xxx" ref="xxxx"/>
                                       <context:component-scan base-package="com.tmall.xxx"/>
                    delegate.parseCustomElement(ele);
                }
            }
        }
    }  else {
              //自定义标签bean的解析
              <context:component-scan base-package="com.tmall.xxx"/>
        delegate.parseCustomElement(root);
        }
}

这个方法主要是针对bean的xml配置文件中默认标签和自定义标签分别进行解析
默认标签的解析方法parseDefaultElement的方法体如下:

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
    if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {  // 对import标签的解析处理
        importBeanDefinitionResource(ele);
    }
    else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) { // 对alias标签的解析处理
        processAliasRegistration(ele);
    }
    else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {//对bean标签的解析处理
        processBeanDefinition(ele, delegate);
      }
      else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {//对beanS标签的解析处理
        processBeanDefinition(ele, delegate);
       }
}

到这个方法,我们终于看到与我们平时写spring bean配置文件相关的代码,下面结bean标签的解析处理代码进行分析
bean标签的解析最终会到parseBeanDefinitionElement方法,这个方法的部分代码如下:
image.png
这个方法的主要工作内容包括:

  1. 提供元素中的id和name属性
  2. 进一步解析其他所有属性并统一封装到AbstractBeanDefinition类型的实例中
  3. 如果检测到bean没有指定的beanName,那么使用默认的规则为此Bean生成beanName
    4.将获取到的信息封装到BeanDefinitionHolder的实例中。

步骤2中对其它标签的解析过程部分源码如下:

public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,
            BeanDefinition containingBean, AbstractBeanDefinition bd) {

    if (ele.hasAttribute(SCOPE_ATTRIBUTE)) {  // scope属性
        // Spring 2.x "scope" attribute
        bd.setScope(ele.getAttribute(SCOPE_ATTRIBUTE));
        if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) { // singleton 属性
            error("Specify either 'scope' or 'singleton', not both", ele);
        }
    }
    else if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {
        // Spring 1.x "singleton" attribute
        bd.setScope(TRUE_VALUE.equals(ele.getAttribute(SINGLETON_ATTRIBUTE)) ?
                BeanDefinition.SCOPE_SINGLETON : BeanDefinition.SCOPE_PROTOTYPE);
    }
    else if (containingBean != null) {
        // Take default from containing bean in case of an inner bean definition.
        bd.setScope(containingBean.getScope());
    }

    if (ele.hasAttribute(ABSTRACT_ATTRIBUTE)) {   // abstract属性
        bd.setAbstract(TRUE_VALUE.equals(ele.getAttribute(ABSTRACT_ATTRIBUTE)));
    }

    String lazyInit = ele.getAttribute(LAZY_INIT_ATTRIBUTE);  // lazy-init属性
    if (DEFAULT_VALUE.equals(lazyInit)) {
        lazyInit = this.defaults.getLazyInit();
    }
    bd.setLazyInit(TRUE_VALUE.equals(lazyInit));

    String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);  //autowire属性
    bd.setAutowireMode(getAutowireMode(autowire));

    String dependencyCheck = ele.getAttribute(DEPENDENCY_CHECK_ATTRIBUTE);
    bd.setDependencyCheck(getDependencyCheck(dependencyCheck));

    if (ele.hasAttribute(DEPENDS_ON_ATTRIBUTE)) {  // depends-on属性
        String dependsOn = ele.getAttribute(DEPENDS_ON_ATTRIBUTE);
        bd.setDependsOn(StringUtils.tokenizeToStringArray(dependsOn, 
                       BEAN_NAME_DELIMITERS));
    }

         // autowire-candidate 属性
    String autowireCandidate = ele.getAttribute(AUTOWIRE_CANDIDATE_ATTRIBUTE);
    if ("".equals(autowireCandidate) || DEFAULT_VALUE.equals(autowireCandidate)) {
        String candidatePattern = this.defaults.getAutowireCandidates();
        if (candidatePattern != null) {
            String[] patterns = StringUtils.commaDelimitedListToStringArray(candidatePattern);
                bd.setAutowireCandidate(PatternMatchUtils.simpleMatch(patterns, beanName));
        }
    }
    else {
        bd.setAutowireCandidate(TRUE_VALUE.equals(autowireCandidate));
    }
        // primary 属性
    if (ele.hasAttribute(PRIMARY_ATTRIBUTE)) {
        bd.setPrimary(TRUE_VALUE.equals(ele.getAttribute(PRIMARY_ATTRIBUTE)));
    }
        // init-method属性
    if (ele.hasAttribute(INIT_METHOD_ATTRIBUTE)) {
        String initMethodName = ele.getAttribute(INIT_METHOD_ATTRIBUTE);
        if (!"".equals(initMethodName)) {
            bd.setInitMethodName(initMethodName);
        }
    }
    else {
        if (this.defaults.getInitMethod() != null) {
            bd.setInitMethodName(this.defaults.getInitMethod());
            bd.setEnforceInitMethod(false);
        }
    }
        // destroy-method属性
    if (ele.hasAttribute(DESTROY_METHOD_ATTRIBUTE)) {
        String destroyMethodName = ele.getAttribute(DESTROY_METHOD_ATTRIBUTE);
        if (!"".equals(destroyMethodName)) {
            bd.setDestroyMethodName(destroyMethodName);
        }
    }
    else {
        if (this.defaults.getDestroyMethod() != null) {
            bd.setDestroyMethodName(this.defaults.getDestroyMethod());
            bd.setEnforceDestroyMethod(false);
        }
    }
       // factory-method 属性
    if (ele.hasAttribute(FACTORY_METHOD_ATTRIBUTE)) {
        bd.setFactoryMethodName(ele.getAttribute(FACTORY_METHOD_ATTRIBUTE));
    }
       // factory-bean 属性
    if (ele.hasAttribute(FACTORY_BEAN_ATTRIBUTE)) {
        bd.setFactoryBeanName(ele.getAttribute(FACTORY_BEAN_ATTRIBUTE));
    }
    return bd;
}

// 解析购造函数constructor-arg标签元素
public void parseConstructorArgElements(Element beanEle, BeanDefinition bd) {
    NodeList nl = beanEle.getChildNodes();
    for (int i = 0; i < nl.getLength(); i++) {
        Node node = nl.item(i);
        if (isCandidateElement(node) && 
                      nodeNameEquals(node, CONSTRUCTOR_ARG_ELEMENT)) {
            parseConstructorArgElement((Element) node, bd);
        }
    }
}
//解析property属性
public void parsePropertyElements(Element beanEle, BeanDefinition bd) {
    NodeList nl = beanEle.getChildNodes();
    for (int i = 0; i < nl.getLength(); i++) {
        Node node = nl.item(i);
        if (isCandidateElement(node) && nodeNameEquals(node, PROPERTY_ELEMENT)) {
            parsePropertyElement((Element) node, bd);
        }
    }
}

其它的标签解析过程请参考下面这个类org.springframework.beans.factory.xml.BeanDefinitionParserDelegate

上面解析分析了默认标签bean的源码解析过程,下面再来看一下自定标签的解析过程,方法位置:org.springframework.beans.factory.xml.BeanDefinitionParserDelegate.parseCustomElement(Element, BeanDefinition)源码如下:

public BeanDefinition parseCustomElement(Element ele, BeanDefinition containingBd) {
         //获取对应的命名空间
    String namespaceUri = getNamespaceURI(ele);
        // 根据命名空间得到对相应的NamespaceHandler 
    NamespaceHandler handler = 
                  this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
    if (handler == null) {
        error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + 
                        namespaceUri + "]", ele);
        return null;
    }
        // 调用自定义的NamespaceHandler handler进行解析
    return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
}

由于spring自定义标签大家在平时用得比较少,由于时间关系和篇幅关系,本来就不对自定义标签进行详细分析,下一篇文章会结合spring源码对自定义标签的使用和解析原理进行详细的介绍分析

由于时间关系,文中有些地方没有写细致,讲得不够清楚,可能不少地方还会出现低级的错误,请大家指正。

目录
相关文章
|
17天前
|
监控 Java 应用服务中间件
高级java面试---spring.factories文件的解析源码API机制
【11月更文挑战第20天】Spring Boot是一个用于快速构建基于Spring框架的应用程序的开源框架。它通过自动配置、起步依赖和内嵌服务器等特性,极大地简化了Spring应用的开发和部署过程。本文将深入探讨Spring Boot的背景历史、业务场景、功能点以及底层原理,并通过Java代码手写模拟Spring Boot的启动过程,特别是spring.factories文件的解析源码API机制。
47 2
|
2月前
|
搜索推荐 Java Spring
Spring Filter深度解析
【10月更文挑战第21天】Spring Filter 是 Spring 框架中非常重要的一部分,它为请求处理提供了灵活的控制和扩展机制。通过合理配置和使用 Filter,可以实现各种个性化的功能,提升应用的安全性、可靠性和性能。还可以结合具体的代码示例和实际应用案例,进一步深入探讨 Spring Filter 的具体应用和优化技巧,使对它的理解更加全面和深入。
|
23天前
|
存储
文件太大不能拷贝到U盘怎么办?实用解决方案全解析
当我们试图将一个大文件拷贝到U盘时,却突然跳出提示“对于目标文件系统目标文件过大”。这种情况让人感到迷茫,尤其是在急需备份或传输数据的时候。那么,文件太大为什么会无法拷贝到U盘?又该如何解决?本文将详细分析这背后的原因,并提供几个实用的方法,帮助你顺利将文件传输到U盘。
|
2月前
|
数据安全/隐私保护 流计算 开发者
python知识点100篇系列(18)-解析m3u8文件的下载视频
【10月更文挑战第6天】m3u8是苹果公司推出的一种视频播放标准,采用UTF-8编码,主要用于记录视频的网络地址。HLS(Http Live Streaming)是苹果公司提出的一种基于HTTP的流媒体传输协议,通过m3u8索引文件按序访问ts文件,实现音视频播放。本文介绍了如何通过浏览器找到m3u8文件,解析m3u8文件获取ts文件地址,下载ts文件并解密(如有必要),最后使用ffmpeg合并ts文件为mp4文件。
|
2月前
|
XML Web App开发 JavaScript
XML DOM 解析器
XML DOM 解析器
|
2月前
|
Java Spring
Spring底层架构源码解析(三)
Spring底层架构源码解析(三)
123 5
|
2月前
|
XML Java 数据格式
Spring底层架构源码解析(二)
Spring底层架构源码解析(二)
|
2月前
|
XML Web App开发 JavaScript
XML DOM 解析器
XML DOM 解析器
|
2月前
|
XML Java 数据格式
Spring IOC容器的深度解析及实战应用
【10月更文挑战第14天】在软件工程中,随着系统规模的扩大,对象间的依赖关系变得越来越复杂,这导致了系统的高耦合度,增加了开发和维护的难度。为解决这一问题,Michael Mattson在1996年提出了IOC(Inversion of Control,控制反转)理论,旨在降低对象间的耦合度,提高系统的灵活性和可维护性。Spring框架正是基于这一理论,通过IOC容器实现了对象间的依赖注入和生命周期管理。
73 0
|
2月前
|
XML Java 数据格式
手动开发-简单的Spring基于注解配置的程序--源码解析
手动开发-简单的Spring基于注解配置的程序--源码解析
47 0

推荐镜像

更多