spring源码-自定义标签-4

Posted 2021-01-26 小不点丶

　　一、自定义标签，自定义标签在使用上面相对来说非常常见了，这个也算是spring对于容器的拓展。通过自定义标签的方式可以创造出很多新的配置方式，并且交给容器直接管理，不需要人工太多的关注。这也是spring对于配置拓展的一个很重要的方式。

　　二、自定义标签的几个步骤：1、创建可扫描的标签和对应的解析类  2、读取页面元素解析 3、加入容器管理

　　三、涉及到的常用类：BeanDefinitionParser、NamespaceHandlerSupport；文件：spring.handlers、spring.schemas、*.xsd

　　四、实现过程：

　　1）需要实现的类：

　　

　　pojo:

public class User{

    private String id;
    private String name;
    private String age;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }

}

　　UserBeanDefinitionParser:

public class UserBeanDefinitionParser implements BeanDefinitionParser {

    //解析xml
    public BeanDefinition parse(Element element, ParserContext parserContext) {
        //通过读取xml的元素来实现具体配置
        String id = element.getAttribute("id");
        String name = element.getAttribute("name");
        String age = element.getAttribute("age");
        //注册到spring容器
        BeanDefinitionRegistry registry = parserContext.getRegistry();
        BeanDefinition beanDefinition = null;
        try {
            //这里的RootBeanDefinition为我们常用的注册形式
            beanDefinition = new RootBeanDefinition(User.class);
            beanDefinition.getPropertyValues().add("id", id);
            beanDefinition.getPropertyValues().add("name", name);
            beanDefinition.getPropertyValues().add("age", age);
            //注册
            registry.registerBeanDefinition(id, beanDefinition);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return beanDefinition;
    }
}

　　UserNameSpaceHandler:

//用于提供namespace的扫描
public class UserNameSpaceHandler extends NamespaceHandlerSupport {

    //初始化
    public void init() {
        //注册解析手段
        registerBeanDefinitionParser("user",new UserBeanDefinitionParser());
    }
}

　　2）因为来了，这个没有啥关联啊。那么久需要用到具体的配置来做关联（spring.handlers、spring.schemas、*.xsd）

　　

　　备注：这个自己默认配置在resources里面就可以。目录必须为META-INF，默认两个文件：spring.handlers、spring.schemas。标签：*.xsd

　　spring.handlers：默认处理的NamespaceHandlerSupport

http\\://www.pinnet.com/schema/user=com.pinnet.customLabel.UserNameSpaceHandler

　　spring.schemas：用于使用的标签格式以及验证

http\\://www.pinnet.com/schema/user.xsd=META-INF/user.xsd

　　user.xsd：这里写了一个简单的例子（标签的编写这里不做介绍，可以自己查询schema的官网）

<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema
        xmlns="http://www.pinnet.com/schema/user"
        xmlns:xsd="http://www.w3.org/2001/XMLSchema"
        xmlns:beans="http://www.springframework.org/schema/beans"
        targetNamespace="http://www.pinnet.com/schema/user"
        elementFormDefault="qualified">
    <xsd:import namespace="http://www.springframework.org/schema/beans"/>
    <xsd:element name="user">
        <xsd:complexType>
            <xsd:complexContent>
                <xsd:extension base="beans:identifiedType">
                    <xsd:attribute name="name" type="xsd:string"/>
                    <xsd:attribute name="age" type="xsd:string"/>
                </xsd:extension>
            </xsd:complexContent>
        </xsd:complexType>
    </xsd:element>
</xsd:schema>

　　3）好了上面的基本准备工作ok了。具体就是容器做的处理了，我们来关注源码的实现部分。

　　spring-bean.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:pinnet="http://www.pinnet.com/schema/user" xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.pinnet.com/schema/user http://www.pinnet.com/schema/user.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    <pinnet:user id="user1" name="name1" age="age1"/>
    <pinnet:user id="user2" name="name2" age="age2"/>
    <pinnet:user id="user3" name="name3" age="age3"/>
</beans>

　　注意：有下划线的部分，这里就是引用过后，然后需要进行的配置。xmlns:pinnet中的pinnet可以自己随便取

　　测试：

public class Test {

    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        User user1 = (User) context.getBean("user1");
        User user2 = (User) context.getBean("user2");
        User user3 = (User) context.getBean("user3");
        System.out.println(user1);
        System.out.println(user2);
        System.out.println(user3);
    }
}

　　4）好了重点来了，源码部分。

　　这里从自定义标签开始讲起：其他部分可以参考:spring源码-bean之初始化-1到7）部分

　　parseCustomElement：

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
        //判断根节点是否是默认的（也就是spring提供的beans）
        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);
        }
    }

public BeanDefinition parseCustomElement(Element ele) {
        //解析配置
        return this.parseCustomElement(ele, (BeanDefinition)null);
    }

    public BeanDefinition parseCustomElement(Element ele, BeanDefinition containingBd) {
        //获取Namespace的uri
        String namespaceUri = this.getNamespaceURI(ele);
        //然后获取NamespaceHandler的实现类NamespaceHandlerSupport的对应实现
        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：

public NamespaceHandler resolve(String namespaceUri) {
        //获取所有NamespaceHandler的NamespaceHandlerSupport实现类（过程不详解了）
        Map<String, Object> handlerMappings = this.getHandlerMappings();
        //获取具体的NamespaceHandlerSupport实现类
        Object handlerOrClassName = handlerMappings.get(namespaceUri);
        if (handlerOrClassName == null) {
            return null;
        } else if (handlerOrClassName instanceof NamespaceHandler) {
            return (NamespaceHandler)handlerOrClassName;
        } else {
            //我们默认第一次通过spring.handlers，一般都是String类型的
            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 {
                    //获取提前加入容器的NamespaceHandler
                    NamespaceHandler namespaceHandler = (NamespaceHandler) BeanUtils.instantiateClass(handlerClass);
                    //调用初始化这里的初始化查看前面的调用
                    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);
            }
        }
    }

　　parse：

public BeanDefinition parse(Element element, ParserContext parserContext) {
        //发现解析的BeanDefinitionParser，并调用实现类的parse方法
        return this.findParserForElement(element, parserContext).parse(element, parserContext);
    }

    private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {
        //获取本地的localName，在NamespaceHandlerSupport中进行了init，所以会直接获取到UserNameSpaceHandler
        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;
    }

　　五：上面基本的实现过程就是这样子了，包含了源码的实现逻辑。这里需要关注的点在于匹配的过程。其他都是自己手动完成的。

　　六、用处：相对于我们人的解析过程，自定义标签的解析的过程并不是很复杂，更多需要自己手动去完成解析。自定义标签的好处在于，可以很大程度的减少代码冗余的情况。通过同一套流程，开发者只需要关注配置就可以了，而不需要关注具体的解析过程和实现逻辑。另外可以更加方便的与spring容器进行深度的整合!