Spring源码解析-自定义标签的解析

首先来讲一下这个自定义标签怎么用：

应用

①创建一个需要拓展的组件，这里我们创建一个pojo类

public class User {
    private String userName;
    private String email;

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }
}

②定义一个XSD结构描述文件，命名为Spring-test.xsd

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<schema xmlns="http://www.w3.org/2001/XMLSchema"
        targetNamespace="http://www.corefuture.cn/schema/user"
        elementFormDefault="qualified">
    <element name="user">
        <complexType>
            <attribute name="id" type="string"/>
            <attribute name="userName" type="string"/>
            <attribute name="email" type="string"/>
        </complexType>
    </element>
</schema>

③创建一个类，实现BeanDefinitionPaser接口，用来解析我们自己定义的标签

package parser;

import bean.User;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.xml.AbstractSingleBeanDefinitionParser;
import org.springframework.util.StringUtils;
import org.w3c.dom.Element;

/**
 * Created by WHZ on 2017/8/15 0015.
 */
public class UserBeanDefinitionPaser extends AbstractSingleBeanDefinitionParser{
    @Override
    protected Class getBeanClass(Element element){
        return User.class;
    }

    @Override
    protected void doParse(Element element, BeanDefinitionBuilder builder) {
        //获取属性userName
        String userName = element.getAttribute("userName");
        //获取属性email
        String email = element.getAttribute("email");
        //添加到BeanDefinitionBuilder
        if(StringUtils.hasText(userName)){
            builder.addPropertyValue("userName",userName);
        }
        if(StringUtils.hasText(email)){
            builder.addPropertyValue("email",email);
        }
    }
}

④创建一个继承了NamespaceHandlerSupport的类，用来将之前的解析器注册到spring容器中

package handler;

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

/**
 * Created by Administrator on 2017/8/15 0015.
 */
public class MyNamespaceHandler extends NamespaceHandlerSupport {
    public void init() {
        registerBeanDefinitionParser("user",new UserBeanDefinitionPaser());
    }
}

⑤在工程文件的META-INF下添加两个文件，如果没有META-INF就自己创建，创建一个spring.hadlers

http\://www.corefuture.cn/schema/user=handler.MyNamespaceHandler

创建一个spring.schemas

http\://www.corefuture.cn/schema/user.xsd=META-INF/Spring-test.xsd

记住这两个文件名最好要小写，因为这样idea这个编译环境能识别这两个文件，然后可以检查出文件内容的错误。
⑥接着就是配置spring的配置文件

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:task="http://www.springframework.org/schema/task"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:myname="http://www.corefuture.cn/schema/user"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/task
        http://www.springframework.org/schema/task/spring-task.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.corefuture.cn/schema/user
        http://www.corefuture.cn/schema/user.xsd">

    <myname:user id="aa" userName="aaaa" email="aaaa"/>
</beans>

⑦测试

package client;

import bean.User;
import org.junit.Test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;

/**
 * Created by Administrator on 2017/8/14 0014.
 */
public class BeanFactoryTest {

    @Test
    public void testSimpleLoad(){
        BeanFactory bf =new XmlBeanFactory(new ClassPathResource(("beanFactoryTest.xml")));
        User myTestBean = (User)bf.getBean("aa");
        System.out.println(myTestBean.getEmail());
    }
}
结果
aaaa

接着来看对自定义标签的解析过程

解析过程

回到之前的代码

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);
        }

    }

当然在解析spring配置文件时，SAX会通过我们在spring.schemas中定义的约束文件的位置，对标签进行校验，接下来来看一下自定义标签的解析。进入parseCustomElement方法。

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

    public BeanDefinition parseCustomElement(Element ele, BeanDefinition containingBd) {
        //获取命名空间
        String namespaceUri = this.getNamespaceURI(ele);
        //根据命名空间赵铎对应的NamespaceHandler
        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));
        }
    }

我们来看一下resolve这个方法
这个是接口方法，所以需要找到实体类，在readerContext初始化时这个NamespaceHandlerResoler已经被初始化为DefaultNamespaceHandlerResolver,然后我们进入这个类的resolve方法。

public NamespaceHandler resolve(String namespaceUri) {
        //获取所有已经配置的handler映射
        Map<String, Object> handlerMappings = this.getHandlerMappings();
        //根据命名空间找到对应的handler或者类名
        Object handlerOrClassName = handlerMappings.get(namespaceUri);
        if(handlerOrClassName == null) {
            return null;
        } else if(handlerOrClassName instanceof NamespaceHandler) {
            //如果是NamespaceHandler，说明已经调用了init方法，注册自定义的解析器，那么直接返回
            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 {
                    //通过反射机制实例化handler
                    NamespaceHandler namespaceHandler = (NamespaceHandler)BeanUtils.instantiateClass(handlerClass);
                    //初始化，就是调用我们自己handler类的方法，将我们自定义的解析器注册到handler中
                    namespaceHandler.init();
                    //记录缓存
                    handlerMappings.put(namespaceUri, namespaceHandler);
                    return namespaceHandler;
                }
            } catch (ClassNotFoundException var7) {
                throw new FatalBeanException("NamespaceHandler class [" + className + "] for namespace [" + namespaceUri + "] not found", var7);
            } catch (LinkageError var8) {
                throw new FatalBeanException("Invalid NamespaceHandler class [" + className + "] for namespace [" + namespaceUri + "]: problem with handler class file or dependent class", var8);
            }
        }
    }

接着我们来看之前的handler.parse方法

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

    private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {
        //获取元素名称也就是<myname:user>的user
        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;
    }

很明显这个返回的解析器是我们之前注册进去的解析器，现在将这解析器取出来执行parse方法，我们定义的解析器没有parse方法，所以肯定在父类或者祖父类中，最后在AbstractBeanDefinitionParser中找到parse方法

public final BeanDefinition parse(Element element, ParserContext parserContext) {
        //对元素进行解析 然后获取beandefiniton
        AbstractBeanDefinition definition = this.parseInternal(element, parserContext);

我们进入这个方法查看，这是个模板方法，模板方法由子类实现，我们要在AbstractSingleBeanDefinitionParser寻找

protected final AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
        //得到一个genericBeanDefinition
        BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();
        String parentName = this.getParentName(element);
        if(parentName != null) {
            builder.getRawBeanDefinition().setParentName(parentName);
        }
        //解析调用我们定义的解析器paser的getBeanClass方法
        Class<?> beanClass = this.getBeanClass(element);
        if(beanClass != null) {
        //设置class          builder.getRawBeanDefinition().setBeanClass(beanClass);
        } else {
            String beanClassName = this.getBeanClassName(element);
            if(beanClassName != null) {
                builder.getRawBeanDefinition().setBeanClassName(beanClassName);
            }
        }

        builder.getRawBeanDefinition().setSource(parserContext.extractSource(element));
        if(parserContext.isNested()) {
            builder.setScope(parserContext.getContainingBeanDefinition().getScope());
        }

        if(parserContext.isDefaultLazyInit()) {
            builder.setLazyInit(true);
        }
        //调用我们的doPase方法
        this.doParse(element, parserContext, builder);
        //将装载完属性的beandefinition返回
        return builder.getBeanDefinition();
    }

继续看原来的方法

        if(definition != null && !parserContext.isNested()) {
            try {
                //获取id
                String id = this.resolveId(element, definition, parserContext);
                //在这里一定要有id，说明我们的标签一定要有id属性。否则就会报错，也就意味着beanName不能被name所代替
                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];
                   //解析name属性，当然主要还是为了获取别名
                String name = element.getAttribute("name");
                if(StringUtils.hasLength(name)) {
                    aliases = StringUtils.trimArrayElements(StringUtils.commaDelimitedListToStringArray(name));
                }
                //装配BeanDefinitionHolder 
                BeanDefinitionHolder holder = new BeanDefinitionHolder(definition, id, aliases);
                //然后注册到spring容器中，当然这个注册和默认标签bean注册是一样的
                this.registerBeanDefinition(holder, parserContext.getRegistry());
                //如果需要就通知监听器
                if(this.shouldFireEvents()) {
                    BeanComponentDefinition componentDefinition = new BeanComponentDefinition(holder);
                    this.postProcessComponentDefinition(componentDefinition);
                    parserContext.registerComponent(componentDefinition);
                }
            } catch (BeanDefinitionStoreException var9) {
                parserContext.getReaderContext().error(var9.getMessage(), element);
                return null;
            }
        }

        return definition;
    }

总结

①通过命名空间，从handlermap映射中获取handler，如果取到了handler类，那么直接返回，如果没有,那返回的肯定是全类名，然后通过全类名用反射机制进行实例化，调用这个handler的init方法注册我们定义的解析器，再放回handlermap中。
②调用handler的parse方法，先找到对应的解析器，然后对元素进行解析，先解析class等一些属性，然后调用我们自己的doParse方法，最后返回承载了各种属性的beandefinition，然后得到元素的id作为beanName，然后将beandefinition，beanName，别名集合装配到beanDefinitionHolder中
③最后将beanDefinitionHolder注册到容器中，正确说是将beanDefinitionHolder中的beandefinition注册到容器中，当然还有别名和beanName之间的映射。这和之前讲过的默认标签的bean注册的过程是一样的。