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

解析方法如下:

    private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
        // 对<import>节点, 调用importBeanDefinitionResource方法解析, 此方法中, 又回到第一步读取配置文件并解析. 如此递归循环.
        if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
            importBeanDefinitionResource(ele);
        }
        // 对<alias>节点, 调用processAliasRegistration进行别名解析
        else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
            processAliasRegistration(ele);
        }
        // <bean>节点调用processBeanDefinition进行解析
        else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
            processBeanDefinition(ele, delegate);
        }
        // <beans>的处理
        else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
            // recurse
            doRegisterBeanDefinitions(ele);
        }
    }

核心方法:

/**
     * Process the given bean element, parsing the bean definition and registering it with
     * the registry.
     */
    protected void processBeanDefinition(Element ele,
            BeanDefinitionParserDelegate delegate) {
        // 委托BeanDefinition类的parseBeanDefinitionElement方法进行元素解析,返回Beandefinition
        // 类型的实例bdHolder 经过这个方法之后,
        // bdHolder实例已经包含了我们配置文件中的各种属性了,例如 : class,name,id,alias
        BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
        if (bdHolder != null) {
            //当返回的bdHolder 不为空的情况下,若存在默认标签的子节点下再有自定义属性,还需要再次对自定义标签进行解析.
            bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
            try {
                // Register the final decorated instance.
                // 解析完成之后,需要对解析后的bdHolder 进行注册,同样注册操作委托给了BeanDefinitionUtils 的 registerBeanDefinition
                BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder,
                        getReaderContext().getRegistry());
            }
            catch (BeanDefinitionStoreException ex) {
                getReaderContext().error(
                        "Failed to register bean definition with name '"
                                + bdHolder.getBeanName() + "'", ele, ex);
            }
            // Send registration event.
            // 最后发出响应事件,通知相关的监听器,这个bean已经加载完了.
            getReaderContext().fireComponentRegistered(
                    new BeanComponentDefinition(bdHolder));
        }
    }

　　之前,我们已经用了大量的时间分析了 BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele); 这句代码;;

接下来就是我们本章的重点:

　　bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
　　首先我们先了解这局话的作用,从语义上讲,这段的码的意识无非是: 如果有需要的话,就对BeanDefinition 进行装饰;那么这句话到底是什么意思呢?
其实代码适用于这样的一个场景:

<bean id="animal" class="test.constructor.Animal">
        <myTag:my   value="p1"/> 
    </bean>

　　好了,废话不多讲,我们继续分析下这段代码的逻辑;

public BeanDefinitionHolder decorateBeanDefinitionIfRequired(Element ele,
            BeanDefinitionHolder definitionHolder) {
        /*
         * 这里将第三个函数设置为null, 那么第三个函数是做什么用的呢? 什么情况下不为空呢?
         * 
         * 其实这第三个参数是父类bean,当对某个嵌套配置进行分析时,这里需要传递父类beanDefinition
         * .分析源代码得知,这里传递的参数其实是为了使用父类的scope属性,以备子类若没有设置scope 时默认使用父类的属性,这里分析的是顶层配置,所以传null
         * ,
         */
        return decorateBeanDefinitionIfRequired(ele, definitionHolder, null);
    }

　　这里将第三个函数设置为null, 那么第三个函数是做什么用的呢? 什么情况下不为空呢?

其实这第三个参数是父类bean,当对某个嵌套配置进行分析时,这里需要传递父类beanDefinition .分析源代码得知,这里传递的参数其实是为了使用父类的scope属性,以备子类若没有设置scope 时默认使用父类的属性,这里分析的是顶层配置,所以传null , 将第三个null 是指为 Null 后进一步追踪;

代码如下:

public BeanDefinitionHolder decorateBeanDefinitionIfRequired(Element ele,
            BeanDefinitionHolder definitionHolder, BeanDefinition containingBd) {

        BeanDefinitionHolder finalDefinition = definitionHolder;

        // Decorate based on custom attributes first.
        // 遍历所有属性,看看是否有适用于修饰的属性
        NamedNodeMap attributes = ele.getAttributes();
        for (int i = 0; i < attributes.getLength(); i++) {
            Node node = attributes.item(i);
            finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);
        }

        // Decorate based on custom nested elements.
        // 遍历所有属性,看看是否有适用于修饰的子元素
        NodeList children = ele.getChildNodes();
        for (int i = 0; i < children.getLength(); i++) {
            Node node = children.item(i);
            if (node.getNodeType() == Node.ELEMENT_NODE) {
                finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);
            }
        }
        return finalDefinition;
    }

　　上面的代码,我们可以看到该方法分别对元素的所有属性和节点进行了decorateIfRequired()方法的调用,我们继续跟踪代码

    public BeanDefinitionHolder decorateIfRequired(Node node,
            BeanDefinitionHolder originalDef, BeanDefinition containingBd) {
        // 获取命名空间
        String namespaceUri = getNamespaceURI(node);
        // 对非默认标签进行修饰
        if (!isDefaultNamespace(namespaceUri)) {
            // 根据命名空间找到对应的处理器
            NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(
                    namespaceUri);
            if (handler != null) {
                // 进行修饰
                return handler.decorate(node, originalDef, new ParserContext(
                        this.readerContext, this, containingBd));
            }
            else if (namespaceUri != null
                    && namespaceUri.startsWith("http://www.springframework.org/")) {
                error("Unable to locate Spring NamespaceHandler for XML schema namespace ["
                        + namespaceUri + "]", node);
            }
            else {
                // A custom namespace, not to be handled by Spring - maybe "xml:...".
                if (logger.isDebugEnabled()) {
                    logger.debug("No Spring NamespaceHandler found for XML schema namespace ["
                            + namespaceUri + "]");
                }
            }
        }
        return originalDef;
    }

　　

　　程序走到这里已经相当清楚了,首先获取属性或者元素的命名空间,以此来判断该元素或属性是否适用于自定义标签的解析条件,找出自定义类型对应的

NamespaceHandler 并进一步解析,
　　我们总结一下 decorateIfRequired 的作用,在 decorateIfRequired 中,我们可以看到对于程序默认的属性或元素是直接忽略过去的,因为在之前已经处理过了,
这里只对自定义标签感兴趣,在这个方法中实现了寻找自定义标签,并根据自定义标签寻找命名空间处理器,并进一步的解析;