【Spring源码解析】Spring XML配置自定义标签的解析

已于 2022-07-21 11:22:10 修改
阅读量328 收藏
点赞数
分类专栏： Spring
于 2022-07-16 22:52:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42798851/article/details/125826330
版权

spring xml java

【Spring源码解析】Spring XML配置自定义标签的解析

1、前言

上两篇文章【Spring源码解析】Spring XML配置默认bean标签解析、【Spring源码解析】Spring xml配置import、alias、beans标签解析 已经完成了XML方式下对所有默认标签的解析，这篇文章说下自定义标签的解析。

  • 自定义标签

这里说下什么是自定义标签的解析，除了上述的默认标签都是对自定义标签的解析。

主要作用的是对除默认标签外的一些功能扩展，说到扩展，要说默认的标签能不能实现需要扩展的功能？

肯定也是可以的，但是为了更方便，spring推出了扩展的功能。

这个扩展的功能其实不只是我们在用，spring的功能也有使用，例如MVC注解驱动的标签 ＜mvc:annotation-driven/＞ 。

2、实例解析

这里我们使用一个自己定义的标签。

2.1、源码初步解析

首先我们先了解下自定义标签的解析。

先看下之前定义的解析默认标签和自定义标签，区别在于是否使用默认标签的命名delegate.isDefaultNamespace(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)) {
                    this.parseDefaultElement(ele, delegate);
                } else {
                    delegate.parseCustomElement(ele);
                }
            }
        }
    } else {
        delegate.parseCustomElement(root);
    }

}

然后看下解析自定义标签,进入方法parseCustomElement :

@Nullable
public BeanDefinition parseCustomElement(Element ele) {
    return this.parseCustomElement(ele, (BeanDefinition)null);
}

@Nullable
public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
    String namespaceUri = this.getNamespaceURI(ele);
    if (namespaceUri == null) {
        return null;
    } else {
        NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
        if (handler == null) {
            this.error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
            return null;
        } else {
            return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
        }
    }
}

这里一共有三个步骤：

  1. getNamespaceURI 获取自定义空间URI。
  2. this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri) 获取自定义解析器。
  3. handler.parse 通过解析器进行转换成 BeanDefination 。

以上就是自定义标签的解析。然后我们就根据具体的源码，实现具体的自定义解析过程。

2.2、自定义实现

  • 创建自定义Bean对象
package com.fankf.bean;

/**
 * @author fankunfeng
 * @date 2022-07-09 23:30
 */
public class Student {

    private String name;
    private String email;
    
    // set/get 省略
}
  • XSD 文件（解析标签）自定义

位置在resources目录下创建META-INF文件夹，并在META-INF 下创建stu.xsd。

<?xml version="1.0" encoding="UTF-8"?>
<schema xmlns="http://www.w3.org/2001/XMLSchema"
        targetNamespace="http://www.fans.com/schema/user"
        xmlns:tns="http://www.fans.com/schema/user"
        elementFormDefault="qualified">

    <element name="user">
        <complexType>
            <attribute name="id" type="string"/>
            <attribute name="name" type="string"/>
            <attribute name="email" type="string"/>
        </complexType>
    </element>
</schema>
  • META-INF 下创建读取映射文件Spring.schemas
    用来查找xsd文件位置。
http://www.fans.com/schema/stu.xsd=META-INF/stu.xsd
  • 解析转换对象
public class StudentBeanDefinationParser extends AbstractSingleBeanDefinitionParser {
    @Override
    protected Class<?> getBeanClass(Element element) {
        return Student.class;
    }
    @Override
    protected void doParse(Element element, BeanDefinitionBuilder builder) {
        String name = element.getAttribute("name");
        String email = element.getAttribute("email");
        // 将所有的数据放入ParserContext 中，等到所有bean解析完成统一放入BeanFactory中
        if (StringUtils.hasText(name))
            builder.addPropertyValue("name", name);
        if (StringUtils.hasText(email))
            builder.addPropertyValue("email", email);
    }

}
  • META-INF下创建文件Spring.handlers
    用来查找handler。
http://www.fans.com/schema/user=com.fankf.spring.StudentNamespaceHandler
  • 进行对象到容器
public class StudentNamespaceHandler extends NamespaceHandlerSupport {

    @Override
    public void init() {
        // 以stu 开始的标签交给 StudentBeanDefinationParser 进行解析
        registerBeanDefinitionParser("user", new StudentBeanDefinationParser());
    }
}
  • XML配置文件bean6.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:stu="http://www.fans.com/schema/user"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                            http://www.fans.com/schema/user http://www.fans.com/schema/stu.xsd">
    <stu:user id="zs" name="zs1" email="123@123.com"/>
</beans>
  • 测试代码
@Test
public void test() {
    BeanFactory context = new XmlBeanFactory(new ClassPathResource("bean6.xml"));
    Student student = (Student) context.getBean("zs");
    System.out.println("【实例使用】" + student.getEmail() + "-" + student.getName());
}

结果： 【实例使用】123@123.com-zs1

以上就完成了自定义标签到解析的过程，我们再次看下解析过程。

2.3、再次进行解析

@Nullable
public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
    String namespaceUri = this.getNamespaceURI(ele);
    if (namespaceUri == null) {
        return null;
    } else {
        NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
        if (handler == null) {
            this.error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
            return null;
        } else {
            return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
        }
    }
}
  • this.getNamespaceURI(ele)

断点调试我们就会发现 this.getNamespaceURI(ele) 返回的就是 我们配置在bean6.xml beans标签中的自定义命名空间 http://www.fans.com/schema/user 。

  • this.readerContext.getNamespaceHandlerResolver()

然后 this.readerContext.getNamespaceHandlerResolver() 会获取解析器。这里解析器有多个，其中就有我们自定义的 http://www.fans.com/schema/user -> com.fankf.spring.StudentNamespaceHandler 。
这里也可以看到解析器对应的文件位置META-INF下spring.handlers文件。

  • 解析过程

这里就进行解析,进入DefaultNamespaceHandlerResolver##resolve方法：

@Nullable
public NamespaceHandler resolve(String namespaceUri) {
    Map<String, Object> handlerMappings = this.getHandlerMappings();
    Object handlerOrClassName = handlerMappings.get(namespaceUri);
    if (handlerOrClassName == null) {
        return null;
    } else if (handlerOrClassName instanceof NamespaceHandler) {
        return (NamespaceHandler)handlerOrClassName;
    } else {
        String className = (String)handlerOrClassName;

        try {
            Class<?> handlerClass = ClassUtils.forName(className, this.classLoader);
            if (!NamespaceHandler.class.isAssignableFrom(handlerClass)) {
                throw new FatalBeanException("Class [" + className + "] for namespace [" + namespaceUri + "] does not implement the [" + NamespaceHandler.class.getName() + "] interface");
            } else {
                NamespaceHandler namespaceHandler = (NamespaceHandler)BeanUtils.instantiateClass(handlerClass);
                namespaceHandler.init();
                handlerMappings.put(namespaceUri, namespaceHandler);
                return namespaceHandler;
            }
        } catch (ClassNotFoundException var7) {
            throw new FatalBeanException("Could not find NamespaceHandler class [" + className + "] for namespace [" + namespaceUri + "]", var7);
        } catch (LinkageError var8) {
            throw new FatalBeanException("Unresolvable class definition for NamespaceHandler class [" + className + "] for namespace [" + namespaceUri + "]", var8);
        }
    }
}

分为几个步骤：

  1. 获取解析对象Object
Map<String, Object> handlerMappings = this.getHandlerMappings();
Object handlerOrClassName = handlerMappings.get(namespaceUri);
  1. 进行初始化
NamespaceHandler namespaceHandler = (NamespaceHandler)BeanUtils.instantiateClass(handlerClass)
  1. init

这个就是我们自定义的方法,作用是把user标签的内容交给StudentBeanDefinationParser 进行解析。
当然我们也可以写多个解析的标签，这里只是示例了一个。

@Override
public void init() {
    // 以stu 开始的标签交给 StudentBeanDefinationParser 进行解析
    registerBeanDefinitionParser("user", new StudentBeanDefinationParser());
}
  1. 放入处理映射缓存
handlerMappings.put(namespaceUri, namespaceHandler);
  • 解析过程 handler.parse
    先创建转换上下文 ParserContext。然后进行解析：
@Nullable
public BeanDefinition parse(Element element, ParserContext parserContext) {
    BeanDefinitionParser parser = this.findParserForElement(element, parserContext);
    return parser != null ? parser.parse(element, parserContext) : null;
}

@Nullable
private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {
    String localName = parserContext.getDelegate().getLocalName(element);
    BeanDefinitionParser parser = (BeanDefinitionParser)this.parsers.get(localName);
    if (parser == null) {
        parserContext.getReaderContext().fatal("Cannot locate BeanDefinitionParser for element [" + localName + "]", element);
    }

    return parser;
}

findParserForElement 的作用是找到我们自定义的解析对象。
我们看到到 parser.parse(element, parserContext) 继续进入：

@Nullable
public final BeanDefinition parse(Element element, ParserContext parserContext) {
    AbstractBeanDefinition definition = this.parseInternal(element, parserContext);
    if (definition != null && !parserContext.isNested()) {
        try {
            String id = this.resolveId(element, definition, parserContext);
            if (!StringUtils.hasText(id)) {
                parserContext.getReaderContext().error("Id is required for element '" + parserContext.getDelegate().getLocalName(element) + "' when used as a top-level tag", element);
            }

            String[] aliases = null;
            if (this.shouldParseNameAsAliases()) {
                String name = element.getAttribute("name");
                if (StringUtils.hasLength(name)) {
                    aliases = StringUtils.trimArrayElements(StringUtils.commaDelimitedListToStringArray(name));
                }
            }

            BeanDefinitionHolder holder = new BeanDefinitionHolder(definition, id, aliases);
            this.registerBeanDefinition(holder, parserContext.getRegistry());
            if (this.shouldFireEvents()) {
                BeanComponentDefinition componentDefinition = new BeanComponentDefinition(holder);
                this.postProcessComponentDefinition(componentDefinition);
                parserContext.registerComponent(componentDefinition);
            }
        } catch (BeanDefinitionStoreException var8) {
            String msg = var8.getMessage();
            parserContext.getReaderContext().error(msg != null ? msg : var8.toString(), element);
            return null;
        }
    }

    return definition;
}

这里就是四个步骤：

  1. 先获取id，String id = this.resolveId(element, definition, parserContext)
  2. 再获取name并处理别名，String name = element.getAttribute(“name”)
  3. 封装bean对应class 对象BeanDefinitionHolder
  4. 完成注册 this.registerBeanDefinition(holder, parserContext.getRegistry());

这里其实和之前解析默认标签最后完成注册的流程相同。

  • 解析过程总结：

总体流程其实是通过<stu:user/> 中的 beans标签中的配置 xmlns:stu=“http://www.fans.com/schema/user” ,找到处理器，然后通过user标签对应上面 init 方法对应的转换类StudentBeanDefinationParser 解析对象，找到后就进了真正自定义解析的过程，最后完成注册。

3. 总结

对比默认标签bean的解析，这里也是比较简单的，也有可能是万事开头难，完成bean标签的解析，之后就感觉 纵享丝滑 。

再接再厉，加油！共勉！

燃尽余火
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring框架的XML扩展特性：让spring加载和解析你自定义的XML文件
aty
04-13 9316
Spring框架从2.0版本开始，提供了基于Schema风格的XML扩展机制，允许开发者扩展最基本的spring配置文件（一般是classpath下的spring.xml）。试想一下，如果我们直接在spring.xml中加入一个自定义标签，会发生什么呢？spring框架启动的时候会报错，因为spring根本不认识我们自定义的，这样对spring.xml的校验就会失败，最终结果就是框架不能启动。有什
自定义xml标签
11-02
结合spring,自定义xml标签，并利用factorybean来代理获取到的标签内容
spring源码学习之：xml配置文件标签自定义
weixin_34352449的博客
08-19 173
Spring框架从2.0版本开始，提供了基于Schema风格的XML扩展机制，允许开发者扩展最基本的spring配置文件（一 般是classpath下的spring.xml）。试想一下，如果我们直接在spring.xml中加入一个自定义标签<mytag id="aty"></matag>，会发生什么呢？spring框架启动的时候会...
Spring XML 自定义标签解析
不务正业的野猴子
02-24 256
在使用dubbo时常常会遇到如下配置: &lt;beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dubbo="http://dubbo.apache.org/schema/dubbo" xmlns="http://www.springframework.org/schema/beans"...
spring自定义xml标签
lilongjiu的专栏
08-04 2162
spring自定义xml标签要实现自定义的xml配置，需要有两个默认spring配置文件来支持。一个是spring.schemas,一个是spring.handlers，前者是为了验证你自定义的xml配置文件是否符合你的格式要求，后者是告诉spring该如何来解析你自定义的配置文件。自定义标签涉及的核心接口为： NamespaceHandler BeanDefinitionParser 实际使用的时
Spring源码解密之自定义标签与解析
08-28
本篇文章将深入探讨Spring自定义标签的定义、解析以及相关源码分析。 首先，自定义标签的定义通常涉及到两个主要步骤： 1. **定义XSD文件**： XSD（XML Schema Definition）文件用于描述XML文档的结构和数据类型...
Spring 5.2.9 06 源码分析-spring自定义标签解析过程
06-20
在Spring框架中，自定义标签解析是扩展Spring配置能力的重要方式。通过自定义标签，开发者可以创建更加符合业务逻辑和可读性强的XML配置文件。本文将深入剖析Spring 5.2.9版本中自定义标签的解析过程，旨在帮助读者...
06 源码分析-spring自定义标签解析过程
06-19
2. **解析标签**：在解析XML文件时，Spring的`DocumentReader`类会遇到自定义标签。这时，它会查找`NamespaceHandler`，并通过`NamespaceHandler`找到对应的`BeanDefinitionParser`来处理这个标签。 3. **调用解析...
Spring源码解密之默认标签的解析
08-28
总的来说，Spring通过源码解析XML配置文件中的默认标签，特别是`<bean>`标签，实现Bean定义的加载和注册，从而构建Bean的依赖关系图。理解这一过程对于深入掌握Spring的工作原理，优化配置，以及解决配置问题至关...
Java Spring 源码解析 Xmind 思维导图
03-20
在Spring源码解析中，时序图用于描绘不同组件之间的调用关系，如AOP代理的生成过程、事件发布机制、数据访问层（DAO）与业务逻辑层（Service）的交互等。这有助于开发者理解Spring如何处理复杂的应用场景。 再者，...
Spring源码阅读之-自定义配置的解析
weiythi的Blog
07-23 1025
Spring源码阅读之-自定义配置的解析上文书：《Spring源码阅读之-bean的解析与注册》说到，Spring根据delegate.parseCustomElement(ele); 方法来解析自定义命名空间的element节点，本篇博文即分析该解析方式是如何工作的。 入口接上文分析，代码在org.springframework.beans.factory.xml.DefaultBeanDefi
Spring IoC的细节--DefaultNamespaceHandlerResolver.resolve(String namespaceUri)
aidaowuqiong的博客
11-30 530
BeanDefinitionParserDelegate： @Nullable public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) { //解析节点的命名空间 String namespaceUri = getNamespaceURI(ele); i...
spring之自定义解析配置类
u011492805的博客
04-15 316
spring 3.0使用PropertyPlaceholderConfigurer 自定义的话，需要继承PropertyPlaceholderConfigurer并重写 protected String resolvePlaceholder(String placeholder, Properties props) { return props.getProperty(place...
第三篇 再读Spring 之 解析自定义XML标签
技术进步那些的事
04-19 1281
再读Spring之自定义XML标签解析 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录再读Spring之自定义XML标签解析为何要自定义？Spring标签的异同关于XML文件标签分类在哪里生效？怎么扩展？一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 作为一个框架级组件，Spring充分考虑了框架的扩展性，对于XML标签也不例外。博主结合个人对Spring源码的阅读和理解聊聊Spring对自定义XML标签的处理。 为何要自定义？ 显然，自定义可以开发人员扩充
spring解析context:annotation-config时所对应的处理类
wangin1013的专栏
05-11 133
spring配置中的响应的处理类 context:component-scan context:annotation-config ..... 以上标签spring解析时，代码delegate.parseCustomElement(ele); 使用了applicationContext.xml注明的命名空间进行查询NamespaceHandler，如下： [code="java...
spring xml 配置文件中标签的解析
weixin_30414155的博客
06-24 99
一个springmvc配置文件的例子为： <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:con...
Spring配置文件标签解析
qq_16268979的博客
09-18 308
前一篇文章说明的头部文件中声明的命名空间，下面就可以用对应的标签，不同的标签有着不同的功能，这都是根据需要使用。这里就介绍其中的几种标签。 1 context:component-scan/标签 组件扫描注解，属性base-package则是用来指定根包，实际上就是告诉spring去扫描指定包下面的类，并注册被@Controller、@Service、@Component、@Respositor...
Spring源码学习——自定义标签
mk33092250的博客
09-01 121
1.自定义标签步骤 创建一个需要扩展的组件 定义xsd文件描述组件内容 创建一个文件，实现BeanDefinitionParser接口，解析xsd文件中的定义和组件定义 创建handler文件，扩展NamespaceHandlerSupport，注册组件到spring容器 编写spring.handlers和spring.schemas文件 2.代码如下 1.编写pojo public cla...
Spring源码（五）— 解析XML配置文件(二) 定制化标签解析流程
最新发布
weixin_43936962的博客
07-29 316
Spring解析定制化标签流程
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值