spring源码阅读笔记（二）——自定义标签

spring扩展之自定义标签

    不知大家在看到那些大牛们在spring里写各种扩展工具，各种方便有没有很羡慕呢？接下来我给大家介绍一下如何通过自定义标签的形式来扩展spring.
    要通过自定义标签来扩展spring，首先我们应该知道spring是如何解析标签，并将其相关信息存储在内部数据结构中的，这样我们才能知道要实现或继承覆写那些接口或抽象类的函数。

    spring在解析xml的过程中会执行到DefaultBeanDifinitionDocumentReader类的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)) {
                    parseDefaultElement(ele, delegate);
                }
                else {
                    delegate.parseCustomElement(ele);
                }
            }
        }
    }
    else {
        delegate.parseCustomElement(root);
    }
}

其中的parseDefaultElement函数是用来解析spring文档中的默认标签，像beans,import等等，而parseCustomElement函数就是用来解析我们自定义标签的入口了。代码如下：

public BeanDefinition parseCustomElement(Element ele) {
    return parseCustomElement(ele, null);
}

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

这里首先获取xml元素的命名空间，然后根据命名空间调哦嗯resolve函数来获取一个NamespaceHandler，重点在这个resolve函数上。点进去：(该函数所属DefaultNamespaceHandlerResolver类)
   

public NamespaceHandler resolve(String namespaceUri) {
    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();
            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);
        }
    }
}

可以看到它首先获取一个handlerMappings，然后剩下的工作就是去根据这个命名空间去获取或使用反射去实例化一个NamespaceHandler，
实例话的时候会调用其init函数来初始化NamespaceHandler，这个函数中可以做一些注册标签解析器的动作，这个后续会详细说明。下面不用我说，你肯定早就点进 getHandlerMappings函数看其实现了吧，这里面它根据handlerMappingsLocation指定的位置，默认就是打好的jar包里的META-INF/spring.handlers文件，PropertiesLoaderUtils.loadAllProperties函数会把所有jar包下的META-INF/spring.handlers文件全部读取一遍，将文件中的类似于
http\://www.springframework.org/schema/p=org.springframework.beans.factory.xml.SimplePropertyNamespaceHandler
这个结构的键值对存于properties中(这一键值对中指定了命名空间和命名空间处理器的对应关系)，转成map从getHandlerMappings返回。所以我们需要编写我们自己的NamespaceHandler类和指定映射关系的spring.handlers文件。

当然要自定义标签，还要写一个定义标签的xsd定义文件和将命名空间指定到你定义的xsd文件映射关系的文件spring.schemas文件，
spring.schemas文件和spring.handlers放到同一目录下。schemas文件内容示例如下：

http\://www.xxxx.com/schema/qmq/qmq-2.0.0.xsd=META-INF/qmq-2.0.0.xsd
http\://www.xxxx.com/schema/qmq/qmq.xsd=META-INF/qmq-2.0.0.xsd

spring中已经给我们提供了一个NamespaceHandlerSupport抽象类，他里面提供了一个存储标签名称到BeanDefinitionParser标签解析器的映射关系的map，调用registerBeanDefinitionParser函数可以注册BeanDefinitionParser到map中去解析相应的标签。BeanDefinitionParser定义如下：

public interface BeanDefinitionParser {
    BeanDefinition parse(Element element, ParserContext content);
}

这样在上文的parseCustomElement中调用NamespaceHandler的parse函数的时候就会根据标签名称调用我们注册的解析器的parse函数代码如下：(NamespaceHandlerSupport)

    protected final void registerBeanDefinitionParser(String elementName, BeanDefinitionParser parser) {
        this.parsers.put(elementName, parser);
    }


    public BeanDefinition parse(Element element, ParserContext parserContext) {
        return findParserForElement(element, parserContext).parse(element, parserContext);
    }


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

剩下的工作就是编写BeanDefinitionParser，spring中为我们提供了一个抽象类AbstractSingleBeanDefinitionParser来方便我们扩展,上面说道BeanDefinitionParser的入口函数是parse，这个函数的实现在AbstractBeanDefinitionParser类中，代码如下：

   

    public final BeanDefinition parse(Element element, ParserContext parserContext) {
        AbstractBeanDefinition definition = parseInternal(element, parserContext);
        if (definition != null && !parserContext.isNested()) {
            try {
                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));
                }
                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函数解析出一个BeanDefinition，然后解析两个通用的属性id和name，我们看parseInternal函数，它的实现在子类AbstractSingleBeanDefinitionParser中：
   

    protected final AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
        BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();
        String parentName = getParentName(element);
        if (parentName != null) {
            builder.getRawBeanDefinition().setParentName(parentName);
        }
        Class<?> beanClass = getBeanClass(element);
        if (beanClass != null) {
            builder.getRawBeanDefinition().setBeanClass(beanClass);
        }
        else {
            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.
            builder.setScope(parserContext.getContainingBeanDefinition().getScope());
        }
        if (parserContext.isDefaultLazyInit()) {
            // Default-lazy-init applies to custom bean definitions as well.
            builder.setLazyInit(true);
        }
        doParse(element, parserContext, builder);
        return builder.getBeanDefinition();
    }

这里先获取bean的parentname，然后获取bean的class，我们看到他先调用的是getBeanClass函数，如果反回空才会调用getBeanClassName，所以我们覆写AbstractSingleBeanDefinitionParser类的时候只要实现这两个中的一个函数就可以了，通常是getBeanClass。从上面的函数中我们还可以看到最后的解析全部委托给了doParse函数，我们解析自己的自定义标签就在这个函数中实现。如果需要更改bean的表示id，还可以覆写resolveId函数。

好了，道理讲完了，上代码，代码示例取自《spring源码深度剖析》69页起：

定义bean用来接收配置：
public class User {
    private String userName;
    private String email;
    //省略set,get方法
}

定义xsd文件user.xsd：
<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns="http://www.excample.com/schema/user"
        xmlns:xsd="http://www.w3.org/2001/XMLSchema"
        targetNamespace="http://www.excample.com/schema/user"
        elementFormDefault="qualified">
    <xsd:element name="user">
        <xsd:complexType>
            <xsd:attribute name="id" type="xsd:string"/>
            <xsd:attribute name="userName" type="xsd:string"/>
            <xsd:attribute name="email" type="xsd:string"/>
        </xsd:complexType>
    </xsd:element>
</xsd:schema>


定义BeanDefinitionParser:
public class UserBeanDefinitionParser extends AbstractSingleBeanDefinitionParser {
    @Override
    protected Class getBeanClass(Element element) {
        return User.class;
    }


    @Override
    protected void doParse(Element element, BeanDefinitionBuilder builder) {
        String userName = element.getAttribute("userName");
        String email = element.getAttribute("email");
        builder.addPropertyValue("userName", userName);
        builder.addPropertyValue("email", email);
    }
}


定义NamespaceHandler:
public class MyNamespaceHandler extends NamespaceHandlerSupport {
    public void init() {
        registerBeanDefinitionParser("user", new UserBeanDefinitionParser());
    }
}


spring.handlers:
http\://http://www.example.com/schema/user=MyNamespaceHandler


spring.schemas:
http\://http://www.example.com/schema/user.xsd=META-INF/user.xsd


测试：
spring.xml配置文件：
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:user="http://www.example.com/schema/user"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.example.com/schema/user http://www.example.com/schema/user.xsd">


    <user:user id="user" userName="test" email="test"/>
</beans>


public static void main(String[] s) {
    ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
    User user = (User)context.getBean("user");
    System.out.print(user.getUesrName() + user.getEmail());
}