1.0 自定义标签的解析.

  在之前的章节中,我们完成了对spring 默认标签的加载过程.那么现在我们将开始新的里程, spring 自定义标签的解析;

代码如下:

  1. /**
  2. * Parse the elements at the root level in the document: "import", "alias", "bean".
  3. *
  4. * @param root the DOM root element of the document
  5. */
  6. protected void parseBeanDefinitions(Element root,
  7. BeanDefinitionParserDelegate delegate) {
  8. // 对Bean的处理
  9. if (delegate.isDefaultNamespace(root)) {
  10. NodeList nl = root.getChildNodes();
  11. for (int i = 0; i < nl.getLength(); i++) {
  12. Node node = nl.item(i);
  13. if (node instanceof Element) {
  14. Element ele = (Element) node;
  15. if (delegate.isDefaultNamespace(ele)) {
  16. // 对Bean的处理,如果是默认
  17. parseDefaultElement(ele, delegate);
  18. }
  19. else {
  20. // 对Bean的处理,如果是自定义
  21. delegate.parseCustomElement(ele);
  22. }
  23. }
  24. }
  25. }
  26. else {
  27. delegate.parseCustomElement(root);
  28. }
  29. }

  本章中,所有的内容都是围绕一句代码 delegate.parseCustomElement(ele); 开始的,

 1.1.0 首先我们看看自定义标签的使用.

  1.1.1 根据Spring提供的扩展Schema 的定义,扩展一个Spring 自定义的标签配置大致需要以下几个步骤,.

    1.  创建一个需要扩展的组件.

    2.  定义一个XSD文件.

    3.  创建一个文件.实现BeanDefinitionParser 接口, 用来解析XSD文件中的定义,和主键定义.

    4.  创建一个Handler 文件,扩展NameSpaceHandleSupport,目的是将组件注册到Spring容器中.

    5.  编写Spring.handlers 和 Spring.schemas 文件

1.1.1 自定义标签的使用过程.

1. 首先我们创建一个普通的pojo

  1. package cn.c.bean;
  2.  
  3. public class MJorcen {
  4. private String name;
  5. private String alias;
  6. private String code;
  7.  
  8. public String getName() {
  9. return name;
  10. }
  11.  
  12. public void setName(String name) {
  13. this.name = name;
  14. }
  15.  
  16. public String getAlias() {
  17. return alias;
  18. }
  19.  
  20. public void setAlias(String alias) {
  21. this.alias = alias;
  22. }
  23.  
  24. public String getCode() {
  25. return code;
  26. }
  27.  
  28. public void setCode(String code) {
  29. this.code = code;
  30. }
  31.  
  32. }

2.定义一个xsd文件描述内容.

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
  3. targetNamespace="http://www.example.org/MJorcen" xmlns:tns="http://www.example.org/MJorcen"
  4. elementFormDefault="qualified">
  5. <xsd:element name="mjorce">
  6. <xsd:complexType>
  7. <xsd:sequence>
  8. <xsd:element name="alias" type="xsd:string"></xsd:element>
  9. <xsd:element name="code" type="xsd:string"></xsd:element>
  10. </xsd:sequence>
  11. <xsd:attribute name="name " type="xsd:string"></xsd:attribute>
  12. <xsd:attribute name="id" type="xsd:string"></xsd:attribute>
  13. </xsd:complexType>
  14. </xsd:element>
  15. </xsd:schema>

注意:没有ID不放行.Spring-4.0.0;

3.创建一个类,实现beanDefinitionParse接口,用来解析xsd文件中的定义和主键定义,一般我们选择的是继承,AbstractSimpleBeanDefinitionParser或者AbstractSingleBeanDefinitionParser来实现

  1. package cn.c.parse;
  2.  
  3. import org.springframework.beans.factory.support.BeanDefinitionBuilder;
  4. import org.springframework.beans.factory.xml.AbstractSimpleBeanDefinitionParser;
  5. import org.springframework.beans.factory.xml.ParserContext;
  6. import org.w3c.dom.Element;
  7. import org.w3c.dom.NodeList;
  8.  
  9. import cn.c.bean.MJorcen;
  10.  
  11. public class MJorcenNamespacesprase extends AbstractSimpleBeanDefinitionParser {
  12.  
  13. @Override
  14. protected Class<?> getBeanClass(Element element) {
  15. return MJorcen.class;
  16. }
  17.  
  18. @Override
  19. protected void doParse(Element element, ParserContext parserContext,
  20. BeanDefinitionBuilder builder) {
  21. String name = element.getAttribute("name");
  22. NodeList eles = element.getChildNodes();
  23. String alias = eles.item(0).getTextContent();
  24. String code = eles.item(1).getTextContent();
  25. builder.addPropertyValue("name", name);
  26. builder.addPropertyValue("alias", alias);
  27. builder.addPropertyValue("code", code);
  28. }
  29.  
  30. }

4.创建一个类,实现NamespaceHandlerSupport接口,目的是将组建注册到Spring 容器

  1. package cn.c.parse;
  2.  
  3. import org.springframework.beans.factory.xml.NamespaceHandlerSupport;
  4.  
  5. public class MJorcenNamespacesHandlers extends NamespaceHandlerSupport {
  6. public static void main(String[] args) {
  7. System.out.println(MJorcenNamespacesHandlers.class);
  8. }
  9.  
  10. public void init() {
  11. registerBeanDefinitionParser("mjorce", new MJorcenNamespacesprase());
  12. }
  13. }

5.编写spring.handlers和spring.schema文件

spring.schema

  1. MJorcen.xsd=cn\c\xml\MJorcen.xsd

spring.handlers

  1. http\://www.example.org/MJorcen=cn.c.parse.MJorcenNamespacesHandlers

到此,自定义的配置就结束了,spring.schema,spring.handlers中去找对应的handler 和XSD文件,默认的位置是META-INF目录下,进而找到对应的handler以及解析元素的parser,进而完成整个自定义标签的解析,也就是说自定义与Spring中的默认标准不同在于,Spring将自定义标签解析的工作委托给了用户去实现.

6.创建xml文件:

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:c="http://www.example.org/MJorcen"
  4. xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
  5. http://www.example.org/MJorcen MJorcen.xsd">
  6.  
  7. <c:mjorce id="mj" name="MichealJorcen">
  8. <c:alias>jorcen</c:alias>
  9. <c:code>088794</c:code>
  10. </c:mjorce>
  11. </beans>

7.创建测试文件

  1. package cn.c.main;
  2.  
  3. import org.springframework.context.ApplicationContext;
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;
  5.  
  6. import cn.c.bean.MJorcen;
  7.  
  8. public class Main {
  9. public static void main(String[] args) {
  10. ApplicationContext ctx = new ClassPathXmlApplicationContext(
  11. "cn/c/xml/applicationContxt.xml");
  12. MJorcen f = (MJorcen) ctx.getBean("MichealJorcen");
  13. System.out.println(f);
  14. }
  15. }

2.0 下面,我们一起进入parseCustomElement方法,代码如下:

  1. public BeanDefinition parseCustomElement(Element ele) {
  2. //containingBd为父类Bean ,顶层元素设置为null
  3. return parseCustomElement(ele, null);
  4. }

追踪下去如下:

  1. /**
  2. * Parse the merge attribute of a collection element, if any.
  3. */
  4. public boolean parseMergeAttribute(Element collectionElement) {
  5. String value = collectionElement.getAttribute(MERGE_ATTRIBUTE);
  6. if (DEFAULT_VALUE.equals(value)) {
  7. value = this.defaults.getMerge();
  8. }
  9. return TRUE_VALUE.equals(value);
  10. }
  11.  
  12. public BeanDefinition parseCustomElement(Element ele) {
  13. //containingBd为父类Bean ,顶层元素设置为null
  14. return parseCustomElement(ele, null);
  15. }
  16. //containingBd为父类Bean ,顶层元素设置为null
  17. public BeanDefinition parseCustomElement(Element ele, BeanDefinition containingBd) {
  18. //获取对应的命名空间
  19. String namespaceUri = getNamespaceURI(ele);
  20. //根据对应的命名空间找到对应的 NamespaceHandler
  21. NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(
  22. namespaceUri);
  23. if (handler == null) {
  24. error("Unable to locate Spring NamespaceHandler for XML schema namespace ["
  25. + namespaceUri + "]", ele);
  26. return null;
  27. }
  28. // 调用NamespaceHandler 注册的parse进行解析,[NamespaceHandlerSupport.java]
  29. return handler.parse(ele, new ParserContext(this.readerContext, this,
  30. containingBd));
  31. }

其实思路很简单,无非就是根据对应的bean获取对应的命名空间,然后根据命名空间找到对应的解析器,然后根据对应的解析器进行解析,说起来容易,做起来可没那么简单,让我们来看看具体实现,

2.1.获取命名空间

标签的解析是从命名空间开始,无论是Spring默认的还是自定义的,都是以命名空间为基础的.至于如何实现,在org.w3c.dom.Node 中已经提供好的方法:

  1. public String getNamespaceURI(Node node) {
  2. return node.getNamespaceURI();
  3. }

2.2 提取自定义标签处理器.

  1. /**
  2. * Locate the {@link NamespaceHandler} for the supplied namespace URI from the
  3. * configured mappings.
  4. *
  5. * @param namespaceUri the relevant namespace URI
  6. * @return the located {@link NamespaceHandler}, or {@code null} if none found
  7. */
  8. @Override
  9. public NamespaceHandler resolve(String namespaceUri) {
  10. // 获取所有已配置的handler映射
  11. Map<String, Object> handlerMappings = getHandlerMappings();
  12. // 根据命名空间找到对应的信息
  13. Object handlerOrClassName = handlerMappings.get(namespaceUri);
  14.  
  15. if (handlerOrClassName == null) {
  16. return null;
  17. }
  18. else if (handlerOrClassName instanceof NamespaceHandler) {
  19. // 已近做过解析的情况直接用缓存中读取
  20. return (NamespaceHandler) handlerOrClassName;
  21. }
  22. else {
  23. // 没有做过解析的,返回的是类路径
  24. String className = (String) handlerOrClassName;
  25. try {
  26. // 反射,转化为类
  27. Class<?> handlerClass = ClassUtils.forName(className, this.classLoader);
  28. if (!NamespaceHandler.class.isAssignableFrom(handlerClass)) {
  29. throw new FatalBeanException("Class [" + className
  30. + "] for namespace [" + namespaceUri
  31. + "] does not implement the ["
  32. + NamespaceHandler.class.getName() + "] interface");
  33. }
  34. // 初始化类
  35. NamespaceHandler namespaceHandler = (NamespaceHandler) BeanUtils.instantiateClass(handlerClass);
  36. // 调用自定义的NamespaceHandler init方法.
  37. namespaceHandler.init();
  38. // 放入缓存
  39. handlerMappings.put(namespaceUri, namespaceHandler);
  40. return namespaceHandler;
  41. }
  42. catch (ClassNotFoundException ex) {
  43. throw new FatalBeanException("NamespaceHandler class [" + className
  44. + "] for namespace [" + namespaceUri + "] not found", ex);
  45. }
  46. catch (LinkageError err) {
  47. throw new FatalBeanException("Invalid NamespaceHandler class ["
  48. + className + "] for namespace [" + namespaceUri
  49. + "]: problem with handler class file or dependent class", err);
  50. }
  51. }
  52. }

当得到命名空间处理器后,马上执行 init() 来注册解析器,如:

public void init() { registerBeanDefinitionParser("mjorce", new MJorcenNamespacesprase()); }

这里,你也可以注册多个解析器, 如<c:M,<c:N 等.使得c的命名空间中可以支持多种标签的解析.

  注册后,命名空间处理器就可以根据标签的不同来调用不同的解析器了.下面我们来看看getHandlerMappings方法

  1. /**
  2. * Load the specified NamespaceHandler mappings lazily.
  3. */
  4. private Map<String, Object> getHandlerMappings() {
  5. // 如果没有被缓存则开始缓存
  6. if (this.handlerMappings == null) {
  7. synchronized (this) {
  8. if (this.handlerMappings == null) {
  9. try {
  10. // this.handlerMappingsLocation 在构造函数中已经被初始化=META-INF/spring.handlers
  11. Properties mappings = PropertiesLoaderUtils.loadAllProperties(
  12. this.handlerMappingsLocation, this.classLoader);
  13. if (logger.isDebugEnabled()) {
  14. logger.debug("Loaded NamespaceHandler mappings: " + mappings);
  15. }
  16. Map<String, Object> handlerMappings = new ConcurrentHashMap<String, Object>(
  17. mappings.size());
  18. //将Properties格式文件合并到Map格式的handlerMappings中
  19. CollectionUtils.mergePropertiesIntoMap(mappings, handlerMappings);
  20. this.handlerMappings = handlerMappings;
  21. }
  22. catch (IOException ex) {
  23. throw new IllegalStateException(
  24. "Unable to load NamespaceHandler mappings from location ["
  25. + this.handlerMappingsLocation + "]", ex);
  26. }
  27. }
  28. }
  29. }
  30. return this.handlerMappings;
  31. }

2.3 标签解析

得到了解析器和需要分析的元素后,Spring就可以将解析工作委托给自定义的解析器了.代码如下:

  1. // 调用NamespaceHandler 注册的parse进行解析
  2. return handler.parse(ele, new ParserContext(this.readerContext, this,
  3. containingBd));

解析个过程中,首先是寻找元素 对应的解析器,进而调用解析器中的parse方法.

那么结合实例,其实就是首先获取在handler中的init方法中注册的对应的Parse 实例.并调用parse方法,但是我们实现的自定义命名空间解析器并没有parse方法,所以推断,这个方法是在父类实现的.

[NamespaceHandlerSupport.java]

  1. @Override
  2. public BeanDefinition parse(Element element, ParserContext parserContext) {
  3. // 寻找解析器,并进行解析
  4. return findParserForElement(element, parserContext).parse(element, parserContext);
  5. }

[NamespaceHandlerSupport.java]

  解析过程中,首先是寻找元素对应的解析器,进而调用解析器的parse 方法.

那么结合实例,其实就是首先获取在handler中的init方法中注册的对应的Parse 实例.并调用parse方法

  1. /**
  2. * Locates the {@link BeanDefinitionParser} from the register implementations using
  3. * the local name of the supplied {@link Element}.
  4. */
  5. private BeanDefinitionParser findParserForElement(Element element,
  6. ParserContext parserContext) {
  7. // 获取元素名称,也就是实例中的:<c:mjorcen 中的 mjorcen,
  8. String localName = parserContext.getDelegate().getLocalName(element);
  9. // 根据mjorcen找到对应的解析器,也就是:registerBeanDefinitionParser("mjorce", new MJorcenNamespacesprase());
  10. BeanDefinitionParser parser = this.parsers.get(localName);
  11.  
  12. if (parser == null) {
  13. parserContext.getReaderContext().fatal(
  14. "Cannot locate BeanDefinitionParser for element [" + localName + "]",
  15. element);
  16. }
  17. return parser;
  18. }

而对于parse方法的处理:

[AbstractBeanDefinitionParser.java]

  1. @Override
  2. public final BeanDefinition parse(Element element, ParserContext parserContext) {
  3. AbstractBeanDefinition definition = parseInternal(element, parserContext);
  4. if (definition != null && !parserContext.isNested()) {
  5. try {
  6. // 获取元素Id属性,如果没有,不放行
  7. String id = resolveId(element, definition, parserContext);
  8. if (!StringUtils.hasText(id)) {
  9. parserContext.getReaderContext().error(
  10. "Id is required for element '"
  11. + parserContext.getDelegate().getLocalName(element)
  12. + "' when used as a top-level tag", element);
  13. }
  14. String[] aliases = new String[0];
  15. String name = element.getAttribute(NAME_ATTRIBUTE);
  16. if (StringUtils.hasLength(name)) {
  17. aliases = StringUtils.trimArrayElements(StringUtils.commaDelimitedListToStringArray(name));
  18. }
  19. // 将AbstractBeanDefinition 转化为 BeanDefinitionHandler
  20. BeanDefinitionHolder holder = new BeanDefinitionHolder(definition, id,
  21. aliases);
  22. registerBeanDefinition(holder, parserContext.getRegistry());
  23. if (shouldFireEvents()) {
  24. // 需要通知监听器则进行处理
  25. BeanComponentDefinition componentDefinition = new BeanComponentDefinition(
  26. holder);
  27. postProcessComponentDefinition(componentDefinition);
  28. parserContext.registerComponent(componentDefinition);
  29. }
  30. }
  31. catch (BeanDefinitionStoreException ex) {
  32. parserContext.getReaderContext().error(ex.getMessage(), element);
  33. return null;
  34. }
  35. }
  36. return definition;
  37. }

从上面可以看到,真正的解析是委托给了函数parseInternal

  在parseInternal 中.并不是直接调用自定义的doParse 方法,而是进行了一系列的数据准备,包括对beanClass,scope,lazyInit等属性的准备.

  1. @Override
  2. protected final AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
  3. BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();
  4. String parentName = getParentName(element);
  5. if (parentName != null) {
  6. builder.getRawBeanDefinition().setParentName(parentName);
  7. }
  8. // 获取自定义标签中的class,此时会调用自定义解析器,如 , getBeanClass方法.
  9. Class<?> beanClass = getBeanClass(element);
  10. if (beanClass != null) {
  11. builder.getRawBeanDefinition().setBeanClass(beanClass);
  12. }
  13. else {
  14. // 如果子类没有实现getBeanClass 则尝试检查子类是否重新getBeanClassName方法.
  15. String beanClassName = getBeanClassName(element);
  16. if (beanClassName != null) {
  17. builder.getRawBeanDefinition().setBeanClassName(beanClassName);
  18. }
  19. }
  20. builder.getRawBeanDefinition().setSource(parserContext.extractSource(element));
  21. if (parserContext.isNested()) {
  22. // Inner bean definition must receive same scope as containing bean.
  23. // 若存在父类,则使用父类的scope属性
  24. builder.setScope(parserContext.getContainingBeanDefinition().getScope());
  25. }
  26. if (parserContext.isDefaultLazyInit()) {
  27. // Default-lazy-init applies to custom bean definitions as well.
  28. //延迟加载
  29. builder.setLazyInit(true);
  30. }
  31. //调用子类的doParse方法.
  32. doParse(element, parserContext, builder);
  33. return builder.getBeanDefinition();
  34. }

到此为止,Spring的解析工作全部结束了.接下来的任务就是如何使用这些bean .

4.4 spring-自定义标签的解析的更多相关文章

  1. Spring源码学习-容器BeanFactory(四) BeanDefinition的创建-自定义标签的解析.md

    写在前面 上文Spring源码学习-容器BeanFactory(三) BeanDefinition的创建-解析Spring的默认标签对Spring默认标签的解析做了详解,在xml元素的解析中,Spri ...

  2. Spring 系列教程之自定义标签的解析

    Spring 系列教程之自定义标签的解析 在之前的章节中,我们提到了在 Spring 中存在默认标签与自定义标签两种,而在上一章节中我们分析了 Spring 中对默认标签的解析过程,相信大家一定已经有 ...

  3. 自己构建一个Spring自定义标签以及原理讲解

    平时不论是在Spring配置文件中引入其他中间件(比如dubbo),还是使用切面时,都会用到自定义标签.那么配置文件中的自定义标签是如何发挥作用的,或者说程序是如何通过你添加的自定义标签实现相应的功能 ...

  4. spring基础---->spring自定义标签(一)

    Spring具有一个基于架构的扩展机制,可以使用xml文件定义和配置bean.本博客将介绍如何编写自定义XML bean的解析器,并用实例来加以说明.其实我一直相信 等你出现的时候我就知道是你. Sp ...

  5. spring自定义标签之 自我实现

     引言: 最近心情比较难以平静,周末的两天就跑出去散心了,西湖边上走走,看日落,还是不错的.回来博客上发现,在自定义标签上,最后一步实现忘记加上了.其实,人生的路程中,我们总是实现着自我的价值,让自己 ...

  6. Spring 自定义标签配置

    前景:经常使用一些依赖于Spring的组件时,发现可以通过自定义配置Spring的标签来实现插件的注入,例如数据库源的配置,Mybatis的配置等.那么这些Spring标签是如何自定义配置的?学习Sp ...

  7. Spring自定义标签的实现

    首先 简单写下 spring xml解析的过程 通过一段简单的 调用spring代码开始 public static void main(String[] args) { ApplicationCon ...

  8. spring自定义标签之 规范定义XSD

    引言: spring的配置文件中,一切的标签都是spring定义好的.<bean/>等等,有了定义的规范,才能让用户填写的正常可用.想写自定义标签,但首先需要了解XML Schema De ...

  9. 基于Spring开发——自定义标签及其解析

    1. XML Schema 1.1 最简单的标签 一个最简单的标签,形式如: <bf:head-routing key="1" value="1" to= ...

  10. Spring自定义标签解析与实现

           在Spring Bean注册解析(一)和Spring Bean注册解析(二)中我们讲到,Spring在解析xml文件中的标签的时候会区分当前的标签是四种基本标签(import.alias ...

随机推荐

  1. Memcached学习(一)

    1.Memcached是什么? 引用维基百科上得简介,Memcached 是一套分布式的高速缓存系统,由LiveJournal的Brad Fitzpatrick开发,目前已被诸如Facebook等许多 ...

  2. (转)Facebook内部分享:26个高效工作的小技巧

    春节假期马上就要结束了,该收收心进入新一年的工作节奏了~分享 26 个高效工作的小技巧,希望对大家有所帮助~(我发现自己只有最后一条执行得很好,并且堪称完美!) 1.时间常有,时间优先. 2.时间总会 ...

  3. SEO前端优化

    精减代码 清除网页中一些冗余的代码,网上有这样的工具,可以辅助完成,如果需要的话,我们可以把代码中的注释去掉,甚至空行之类的也去掉,尽量的减少代码量,从而减小页面体积. CSS Sprites 通俗点 ...

  4. 前端性能优化工具--DOM Monster

    当我们开发web应用的时候,性能是一个永远不能回避的问题.其实对于DOM的性能调试也是一个不可或缺的过程.使用DOM monster你只需要添加到你的”书签中“,在任何需要调试的页面点击这个书签,它就 ...

  5. Spring PecClinic宠物医院---安装

    1.下载源代码 如果本地安装了Git工具,可以直接使用命令 git clone https://github.com/spring-projects/spring-petclinic.git 如果没有 ...

  6. HTML5新增结构标签

    引言 在本节中,笔者将向大家讲述三部分内容,分别介绍HTML5时代的召唤,跟HTML4的区别,以及HTML5中带来的新的结构标签. HTML5时代的召唤 HTML4与HTML5的区别 HTML5新结构 ...

  7. Cassandra1.2文档学习(16)—— 模式的变化

    参考文档:http://www.datastax.com/documentation/cassandra/1.2/webhelp/index.html#cassandra/dml/dml_schema ...

  8. linux 学习笔记2

    vi  编辑命令并查看 i 插入 esc  转换模式 shift + : x  保存并退出    q  不保存  !强制保存 五个查看命令 cat / less / more / tail / hea ...

  9. ZENCART 打开/关闭日志文件

    优秀的php开源程序很多都只带生成日志文件的功能,这类功能的开发可以帮助到站长在调试网站的时候及时的改正网站存在的错误,但是这类错误日志由来并非网站出现什么严重不可挽救的错误,大部分是一些未定义变量这 ...

  10. 35 个必须有的Bootstrap工具和生成器

    Bootstraptor If you think that bootstrap templates are not enough for you, you should go with bootst ...