Spring 中的 XML schema 扩展机制

时间 2019-11-07

原文原文链接

前言

好久没有写关于 Spring 的文章了，最近在系统梳理 Dubbo 代码的过程当中发现了 XML schema 这个被遗漏的知识点。因为工做中使用 SpringBoot 比较多的缘由，几乎不多接触 XML，此文能够算作是亡羊补牢，另外一方面，也为后续的 Dubbo 源码解析作个铺垫。php

XML schema 扩展机制是啥？这并非一块很大的知识点，翻阅一下 Spring 的文档，我甚至没找到一个贯穿上下文的词来描述这个功能，XML Schema Authoring 是文档中对应的标题，简单来讲：spring

Spring 为基于 XML 构建的应用提供了一种扩展机制，用于定义和配置 Bean。它容许使用者编写自定义的 XML bean 解析器，并将解析器自己以及最终定义的 Bean 集成到 Spring IOC 容器中。服务器

Dubbo 依赖了 Spring，并提供了一套自定义的 XML 标签，<dubbo:application> ,<dubbo:registry> ,<dubbo:protocol>,<dubbo:service>。做为使用者，大多数人只须要关心这些参数如何配置，但不知道有没有人好奇过，它们是如何加载进入 Spring 的 IOC 容器中被其余组件使用的呢？这便牵扯出了今天的主题：Spring 对 XML schema 的扩展支持。微信

自定义 XML 扩展

为了搞懂 Spring 的 XML 扩展机制，最直接的方式即是实现一个自定义的扩展。实现的步骤也很是简单，分为四步：app

编写一个 XML schema 文件描述的你节点元素。
编写一个 NamespaceHandler 的实现类
编写一个或者多个 BeanDefinitionParser 的实现 (关键步骤).
注册上述的 schema 和 handler。

咱们的目的即是想要实现一个 kirito XML schema，咱们的项目中能够自定义 kirito.xml，在其中会以 kirito 为标签来定义不一样的类，并在最终的测试代码中验证这些声明在 kirito.xml 的类是否被 Spring 成功加载。大概像这样，是否是和 dubbo.xml 的格式很像呢？eclipse

动手实现

有了明确的目标，咱们逐步开展本身的工做。ide

1 编写kirito.xsd

resources/META-INF/kirito.xsd测试

<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns="http://www.cnkirito.moe/schema/kirito" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:beans="http://www.springframework.org/schema/beans" targetNamespace="http://www.cnkirito.moe/schema/kirito">  ①

    <xsd:import namespace="http://www.springframework.org/schema/beans"/>

    <xsd:element name="application"> ②
        <xsd:complexType>
            <xsd:complexContent>
                <xsd:extension base="beans:identifiedType">
                    <xsd:attribute name="name" type="xsd:string" use="required"/>
                </xsd:extension>
            </xsd:complexContent>
        </xsd:complexType>
    </xsd:element>

    <xsd:element name="service"> ②
        <xsd:complexType>
            <xsd:complexContent>
                <xsd:extension base="beans:identifiedType">
                    <xsd:attribute name="name" type="xsd:string" use="required"/>
                </xsd:extension>
            </xsd:complexContent>
        </xsd:complexType>
    </xsd:element>


</xsd:schema>
复制代码

① 注意这里的 targetNamespace="http://www.cnkirito.moe/schema/kirito" 这即是以后 kirito 标签的关键点。ui

② kirito.xsd 定义了两个元素： application 和 service，出于简单考虑，都只有一个 name 字段。this

schema 的意义在于它能够和 eclipse/IDEA 这样智能化的集成开发环境造成很好的搭配，在编辑 XML 的过程当中，用户能够得到告警和提示。若是配置得当，可使用自动完成功能让用户在事先定义好的枚举类型中进行选择。

2 编写KiritoNamespaceHandler

public class KiritoNamespaceHandler extends NamespaceHandlerSupport {

    @Override
    public void init() {
        super.registerBeanDefinitionParser("application", new KiritoBeanDefinitionParser(ApplicationConfig.class));
        super.registerBeanDefinitionParser("service", new KiritoBeanDefinitionParser(ServiceBean.class));
    }

}
复制代码

完成 schema 以后，还须要一个 NamespaceHandler 来帮助 Spring 解析 XML 中不一样命名空间的各种元素。

<kirito:application name="kirito"/>
<dubbo:application name="dubbo"/>
<motan:application name="motan"/>
复制代码

不一样的命名空间须要不一样的 NamespaceHandler 来处理，在今天的示例中，咱们使用 KiritoNamespaceHandler 来解析 kirito 命名空间。KiritoNamespaceHandler 继承自 NamespaceHandlerSupport 类，并在其 init() 方法中注册了两个 BeanDefinitionParser ，用于解析 kirito 命名空间/kirito.xsd 约束中定义的两个元素：application，service。BeanDefinitionParser 是下一步的主角，咱们暂且跳过，将重心放在父类 NamespaceHandlerSupport 之上。

public interface NamespaceHandler {
   void init();
   BeanDefinition parse(Element element, ParserContext parserContext);
   BeanDefinitionHolder decorate(Node source, BeanDefinitionHolder definition, ParserContext parserContext);
}
复制代码

NamespaceHandlerSupport 是 NamespaceHandler 命名空间处理器的抽象实现，我粗略看了NamespaceHandler 的几个实现类，parse 和 decorate 方法能够完成元素节点的组装并经过 ParserContext 注册到 Ioc 容器中，但实际咱们并无调用这两个方法，而是经过 init() 方法注册 BeanDefinitionParser 来完成解析节点以及注册 Bean 的工做，因此对于 NamespaceHandler，咱们主要关心 init 中注册的两个 BeanDefinitionParser 便可。

3 编写KiritoBeanDefinitionParser

在文章开始咱们便标记到 BeanDefinitionParser 是最为关键的一环，每个 BeanDefinitionParser 实现类都负责一个映射，将一个 XML 节点解析成 IOC 容器中的一个实体类。

public class KiritoBeanDefinitionParser implements BeanDefinitionParser {

    private final Class<?> beanClass;

    public KiritoBeanDefinitionParser(Class<?> beanClass) {
        this.beanClass = beanClass;
    }

    private static BeanDefinition parse(Element element, ParserContext parserContext, Class<?> beanClass) {
        RootBeanDefinition beanDefinition = new RootBeanDefinition();
        beanDefinition.setBeanClass(beanClass);
        beanDefinition.setLazyInit(false);
        String name = element.getAttribute("name");
        beanDefinition.getPropertyValues().addPropertyValue("name", name);
        parserContext.getRegistry().registerBeanDefinition(name, beanDefinition);
        return beanDefinition;
    }

    @Override
    public BeanDefinition parse(Element element, ParserContext parserContext) {
        return parse(element, parserContext, beanClass);
    }

}
复制代码

因为咱们的实体类是很是简单的，因此不存在很复杂的解析代码，而实际项目中，每每须要大量的解析步骤。parse 方法会解析一个个 XML 中的元素，使用 RootBeanDefinition 组装成对象，并最终经过 parserContext 注册到 IOC 容器中。

至此，咱们便完成了 XML 文件中定义的对象到 IOC 容器的映射。

4 注册schema和handler

最后一步还须要通知 Spring，告知其自定义 schema 的所在之处以及对应的处理器。

resources/META-INF/spring.handlers

http\://www.cnkirito.moe/schema/kirito=moe.cnkirito.sample.xsd.KiritoNamespaceHandler
复制代码

resources/META-INF/spring.schemas

http\://www.cnkirito.moe/schema/kirito/kirito.xsd=META-INF/kirito.xsd
复制代码

没有太多能够说的，须要遵照 Spring 的约定。

至此一个自定义的 XML schema 便扩展完成了，随后来验证一下。

验证扩展

咱们首先定义好 kirito.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:kirito="http://www.cnkirito.moe/schema/kirito" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.cnkirito.moe/schema/kirito http://www.cnkirito.moe/schema/kirito/kirito.xsd">

    <kirito:application name="kirito-demo-application"/>

    <kirito:service name="kirito-demo-service"/>

</beans>
复制代码

使用 Spring 去加载它，并验证 IOC 容器中是否存在注册成功的 Bean。

@SpringBootApplication
@ImportResource(locations = {"classpath:kirito.xml"})
public class XmlSchemaAuthoringSampleApplication {

   public static void main(String[] args) {
        ConfigurableApplicationContext applicationContext = SpringApplication.run(XmlSchemaAuthoringSampleApplication.class, args);
        ServiceBean serviceBean = applicationContext.getBean(ServiceBean.class);
        System.out.println(serviceBean.getName());
        ApplicationConfig applicationConfig = applicationContext.getBean(ApplicationConfig.class);
        System.out.println(applicationConfig.getName());
    }
}
复制代码

观察控制台的输出：

kirito-demo-service kirito-demo-application

一个基础的基于 XML schema 的扩展便完成了。

Dubbo中的XML schema扩展

最后咱们以 Dubbo 为例，看看一个成熟的 XML schema 扩展是如何被应用的。

恰好对应了四个标准的扩展步骤，是否是对 XML 配置下的 Dubbo 应用有了更好的理解了呢？

顺带一提，仅仅完成 Bean 的注册仍是不够的，在“注册”的同时，Dubbo 还进行了一系列其余操做如：暴露端口，开启服务器，完成注册中心的注册，生成代理对象等等行为，因为不在本文的范围内，后续的 Dubbo 专题会专门介绍这些细节，本文即是了解 Dubbo 加载流程的前置文章了。

欢迎关注个人微信公众号：「Kirito的技术分享」，关于文章的任何疑问都会获得回复，带来更多 Java 相关的技术分享。