4.4 spring-自定义标签的解析

1.0 自定义标签的解析.

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

代码如下:

     /**
      * Parse the elements at the root level in the document: "import", "alias", "bean".
      *
      * @param root the DOM root element of the document
      */
     protected void parseBeanDefinitions(Element root,
             BeanDefinitionParserDelegate delegate) {
         // 对Bean的处理
         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的处理,如果是默认
                         parseDefaultElement(ele, delegate);
                     }
                     else {
                         // 对Bean的处理,如果是自定义
                         delegate.parseCustomElement(ele);
                     }
                 }
             }
         }
         else {
             delegate.parseCustomElement(root);
         }
     }

　　本章中,所有的内容都是围绕一句代码 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

 package cn.c.bean;

 public class MJorcen {
     private String name;
     private String alias;
     private String code;

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public String getAlias() {
         return alias;
     }

     public void setAlias(String alias) {
         this.alias = alias;
     }

     public String getCode() {
         return code;
     }

     public void setCode(String code) {
         this.code = code;
     }

 }

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

<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    targetNamespace="http://www.example.org/MJorcen" xmlns:tns="http://www.example.org/MJorcen"
    elementFormDefault="qualified">
    <xsd:element name="mjorce">
        <xsd:complexType>
            <xsd:sequence>
                <xsd:element name="alias" type="xsd:string"></xsd:element>
                <xsd:element name="code" type="xsd:string"></xsd:element>
            </xsd:sequence>
            <xsd:attribute name="name " type="xsd:string"></xsd:attribute>
            <xsd:attribute name="id" type="xsd:string"></xsd:attribute>
        </xsd:complexType>
    </xsd:element>
</xsd:schema>

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

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

package cn.c.parse;

import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.xml.AbstractSimpleBeanDefinitionParser;
import org.springframework.beans.factory.xml.ParserContext;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;

import cn.c.bean.MJorcen;

public class MJorcenNamespacesprase extends AbstractSimpleBeanDefinitionParser {

    @Override
    protected Class<?> getBeanClass(Element element) {
        return MJorcen.class;
    }

    @Override
    protected void doParse(Element element, ParserContext parserContext,
            BeanDefinitionBuilder builder) {
        String name = element.getAttribute("name");
        NodeList eles = element.getChildNodes();
        String alias = eles.item(0).getTextContent();
        String code = eles.item(1).getTextContent();
        builder.addPropertyValue("name", name);
        builder.addPropertyValue("alias", alias);
        builder.addPropertyValue("code", code);
    }

}

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

package cn.c.parse;

import org.springframework.beans.factory.xml.NamespaceHandlerSupport;

public class MJorcenNamespacesHandlers extends NamespaceHandlerSupport {
    public static void main(String[] args) {
        System.out.println(MJorcenNamespacesHandlers.class);
    }

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

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

spring.schema

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

spring.handlers

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

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

6.创建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:c="http://www.example.org/MJorcen"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
    http://www.example.org/MJorcen MJorcen.xsd">

    <c:mjorce id="mj" name="MichealJorcen">
        <c:alias>jorcen</c:alias>
        <c:code>088794</c:code>
    </c:mjorce>
</beans> 

7.创建测试文件

package cn.c.main;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import cn.c.bean.MJorcen;

public class Main {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext(
                "cn/c/xml/applicationContxt.xml");
        MJorcen f = (MJorcen) ctx.getBean("MichealJorcen");
        System.out.println(f);
    }
}

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

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

追踪下去如下:

    /**
     * Parse the merge attribute of a collection element, if any.
     */
    public boolean parseMergeAttribute(Element collectionElement) {
        String value = collectionElement.getAttribute(MERGE_ATTRIBUTE);
        if (DEFAULT_VALUE.equals(value)) {
            value = this.defaults.getMerge();
        }
        return TRUE_VALUE.equals(value);
    }

    public BeanDefinition parseCustomElement(Element ele) {
        //containingBd为父类Bean ,顶层元素设置为null
        return parseCustomElement(ele, null);
    }
    //containingBd为父类Bean ,顶层元素设置为null
    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 注册的parse进行解析,[NamespaceHandlerSupport.java]
        return handler.parse(ele, new ParserContext(this.readerContext, this,
                containingBd));
    }

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

2.1.获取命名空间

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

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

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

    /**
     * Locate the {@link NamespaceHandler} for the supplied namespace URI from the
     * configured mappings.
     *
     * @param namespaceUri the relevant namespace URI
     * @return the located {@link NamespaceHandler}, or {@code null} if none found
     */
    @Override
    public NamespaceHandler resolve(String namespaceUri) {
        // 获取所有已配置的handler映射
        Map<String, Object> handlerMappings = 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");
                }
                // 初始化类
                NamespaceHandler namespaceHandler = (NamespaceHandler) BeanUtils.instantiateClass(handlerClass);
                // 调用自定义的NamespaceHandler init方法.
                namespaceHandler.init();
                // 放入缓存
                handlerMappings.put(namespaceUri, namespaceHandler);
                return namespaceHandler;
            }
            catch (ClassNotFoundException ex) {
                throw new FatalBeanException("NamespaceHandler class [" + className
                        + "] for namespace [" + namespaceUri + "] not found", ex);
            }
            catch (LinkageError err) {
                throw new FatalBeanException("Invalid NamespaceHandler class ["
                        + className + "] for namespace [" + namespaceUri
                        + "]: problem with handler class file or dependent class", err);
            }
        }
    }

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

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

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

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

/**
     * Load the specified NamespaceHandler mappings lazily.
     */
    private Map<String, Object> getHandlerMappings() {
        // 如果没有被缓存则开始缓存
        if (this.handlerMappings == null) {
            synchronized (this) {
                if (this.handlerMappings == null) {
                    try {
                        // this.handlerMappingsLocation 在构造函数中已经被初始化=META-INF/spring.handlers
                        Properties mappings = PropertiesLoaderUtils.loadAllProperties(
                                this.handlerMappingsLocation, this.classLoader);
                        if (logger.isDebugEnabled()) {
                            logger.debug("Loaded NamespaceHandler mappings: " + mappings);
                        }
                        Map<String, Object> handlerMappings = new ConcurrentHashMap<String, Object>(
                                mappings.size());
                        //将Properties格式文件合并到Map格式的handlerMappings中
                        CollectionUtils.mergePropertiesIntoMap(mappings, handlerMappings);
                        this.handlerMappings = handlerMappings;
                    }
                    catch (IOException ex) {
                        throw new IllegalStateException(
                                "Unable to load NamespaceHandler mappings from location ["
                                        + this.handlerMappingsLocation + "]", ex);
                    }
                }
            }
        }
        return this.handlerMappings;
    }

2.3 标签解析

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

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

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

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

[NamespaceHandlerSupport.java]

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

[NamespaceHandlerSupport.java]

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

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

/**
     * Locates the {@link BeanDefinitionParser} from the register implementations using
     * the local name of the supplied {@link Element}.
     */
    private BeanDefinitionParser findParserForElement(Element element,
            ParserContext parserContext) {
        // 获取元素名称,也就是实例中的:<c:mjorcen 中的 mjorcen,
        String localName = parserContext.getDelegate().getLocalName(element);
        // 根据mjorcen找到对应的解析器,也就是:registerBeanDefinitionParser("mjorce", new MJorcenNamespacesprase());
        BeanDefinitionParser parser = this.parsers.get(localName);

        if (parser == null) {
            parserContext.getReaderContext().fatal(
                    "Cannot locate BeanDefinitionParser for element [" + localName + "]",
                    element);
        }
        return parser;
    }

而对于parse方法的处理:

[AbstractBeanDefinitionParser.java]

@Override
    public final BeanDefinition parse(Element element, ParserContext parserContext) {
        AbstractBeanDefinition definition = parseInternal(element, parserContext);
        if (definition != null && !parserContext.isNested()) {
            try {
                // 获取元素Id属性,如果没有,不放行
                String id = 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 = new String[0];
                String name = element.getAttribute(NAME_ATTRIBUTE);
                if (StringUtils.hasLength(name)) {
                    aliases = StringUtils.trimArrayElements(StringUtils.commaDelimitedListToStringArray(name));
                }
                // 将AbstractBeanDefinition 转化为 BeanDefinitionHandler
                BeanDefinitionHolder holder = new BeanDefinitionHolder(definition, id,
                        aliases);
                registerBeanDefinition(holder, parserContext.getRegistry());
                if (shouldFireEvents()) {
                    // 需要通知监听器则进行处理
                    BeanComponentDefinition componentDefinition = new BeanComponentDefinition(
                            holder);
                    postProcessComponentDefinition(componentDefinition);
                    parserContext.registerComponent(componentDefinition);
                }
            }
            catch (BeanDefinitionStoreException ex) {
                parserContext.getReaderContext().error(ex.getMessage(), element);
                return null;
            }
        }
        return definition;
    }

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

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

@Override
    protected final AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
        BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();
        String parentName = getParentName(element);
        if (parentName != null) {
            builder.getRawBeanDefinition().setParentName(parentName);
        }
        // 获取自定义标签中的class,此时会调用自定义解析器,如 , getBeanClass方法.
        Class<?> beanClass = getBeanClass(element);
        if (beanClass != null) {
            builder.getRawBeanDefinition().setBeanClass(beanClass);
        }
        else {
            // 如果子类没有实现getBeanClass 则尝试检查子类是否重新getBeanClassName方法.
            String beanClassName = getBeanClassName(element);
            if (beanClassName != null) {
                builder.getRawBeanDefinition().setBeanClassName(beanClassName);
            }
        }
        builder.getRawBeanDefinition().setSource(parserContext.extractSource(element));
        if (parserContext.isNested()) {
            // Inner bean definition must receive same scope as containing bean.
            // 若存在父类,则使用父类的scope属性
            builder.setScope(parserContext.getContainingBeanDefinition().getScope());
        }
        if (parserContext.isDefaultLazyInit()) {
            // Default-lazy-init applies to custom bean definitions as well.
            //延迟加载
            builder.setLazyInit(true);
        }
        //调用子类的doParse方法.
        doParse(element, parserContext, builder);
        return builder.getBeanDefinition();
    }

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