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