四、Spring源码解析：IOC-自定义标签的解析

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

在上一篇文章中，我们分析了Spring中对默认标签的解析过程，那么本文将探寻自定义标签的解析过程。首先我们回到Bean定义解析的方法：

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

在本文中，所有的功能都是围绕delegate.parseCustomElement(ele);这一句代码展开的。在分析自定义标签的解析过程前，我们先了解一下自定义标签的使用过程。

自定义标签的使用

扩展Spring自定义标签配置大致需要以下几个步骤：

• 创建一个需要扩展的组件。
• 定义一个XSD文件描述组件内容。
• 创建一个文件，实现BeanDefinitionParser接口，用来解析XSD文件中的定义和组件定义。
• 创建一个Handler文件，扩展自NamespaceHandlerSupport，目的是将组件注册到Spring容器中。
• 编写Spring.handlers和Spring.schemas文件。

具体使用细节就不再这里说明了，我们直接看解析过程的源代码。

自定义标签的解析

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

熟悉的重载的使用。

@Nullable
//containingBd为父类bean，对顶层元素的解析应设置为null
public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
    //获取对应的命名空间
   String namespaceUri = getNamespaceURI(ele);
   if (namespaceUri == null) {
      return null;
   }
    //根据命名空间找对对应的NamespaceHandler
   NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
   if (handler == null) {
      error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
      return null;
   }
    //调用自定义的NamespaceHandler进行解析
   return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
}

其实思路比较简单，无非是根据对应的bean获取对应的命名空间，根据命名空间解析对应的处理器，然后根据用户自定义的处理器进行解析。可是有些事情说起来容易做起来难，我们先看一下如何获取命名空间。

获取标签的命名空间

@Nullable
public String getNamespaceURI(Node node) {
   return node.getNamespaceURI();
}

在org.w3c.dom.Node中已经提供了获取命名空间的方法供我们使用。

提取自定义标签处理器

有了命名空间，就可以进行NamespaceHandler的提取了，我们进入DefaultNamespaceHandlerResolver查看resolve方法：

@Override
@Nullable
public NamespaceHandler resolve(String namespaceUri) {
    //获取所有已经配置的handler映射
   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的初始化方法
         namespaceHandler.init();
          //记录在缓存
         handlerMappings.put(namespaceUri, namespaceHandler);
         return namespaceHandler;
      }
      catch (ClassNotFoundException ex) {
         throw new FatalBeanException("Could not find NamespaceHandler class [" + className +
               "] for namespace [" + namespaceUri + "]", ex);
      }
      catch (LinkageError err) {
         throw new FatalBeanException("Unresolvable class definition for NamespaceHandler class [" +
               className + "] for namespace [" + namespaceUri + "]", err);
      }
   }
}

标签解析

得到了解析器以及要分析的元素后，Spring就可以将解析工作委托给自定义解析器去解析了。

@Override
@Nullable
public BeanDefinition parse(Element element, ParserContext parserContext) {
   BeanDefinitionParser parser = findParserForElement(element, parserContext);
   return (parser != null ? parser.parse(element, parserContext) : null);
}

解析过程中首先是寻找元素对应的解析器，进而调用解析器中parse方法。

@Nullable
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;
}

而对于parse方法的处理：

@Override
@Nullable
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 = null;
         if (shouldParseNameAsAliases()) {
            String name = element.getAttribute(NAME_ATTRIBUTE);
            if (StringUtils.hasLength(name)) {
               aliases = StringUtils.trimArrayElements(StringUtils.commaDelimitedListToStringArray(name));
            }
         }
          //将AbstractBeanDefinition转换成BeanDefinitionHolder并注册
         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) {
         String msg = ex.getMessage();
         parserContext.getReaderContext().error((msg != null ? msg : ex.toString()), element);
         return null;
      }
   }
   return definition;
}

虽说是对自定义配置文件的解析，但是，我们可以看到，在这个函数中大部分的代码使用来处理将解析后的AbstractBeanDefinition转化成BeanDefinitionHolder并注册的功能，而真正去解析的是parseInternal方法，正式这句代码调用了我们自定义的解析方法。

在parseInternal中并不是直接调用自定义的doParse函数，而是进行了一系列的数据准备，包括beanClass、scope、lazyInit等属性的准备：

protected final AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
   BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();
   String parentName = getParentName(element);
   if (parentName != null) {
      builder.getRawBeanDefinition().setParentName(parentName);
   }
    //获取自定义标签中的class，此时会调用自定义解析器中的getBeanClass方法
   Class<?> beanClass = getBeanClass(element);
   if (beanClass != null) {
      builder.getRawBeanDefinition().setBeanClass(beanClass);
   }
   else {
       //若子类没有重写getBeanClass方法则尝试检查子类是否重写getBeanClassName方法
      String beanClassName = getBeanClassName(element);
      if (beanClassName != null) {
         builder.getRawBeanDefinition().setBeanClassName(beanClassName);
      }
   }
   builder.getRawBeanDefinition().setSource(parserContext.extractSource(element));
   BeanDefinition containingBd = parserContext.getContainingBeanDefinition();
   if (containingBd != null) {
       //若存在父类则使用父类的scope
      // Inner bean definition must receive same scope as containing bean.
      builder.setScope(containingBd.getScope());
   }
   if (parserContext.isDefaultLazyInit()) {
       //配置延迟加载
      // Default-lazy-init applies to custom bean definitions as well.
      builder.setLazyInit(true);
   }
    //调用子类重写的doParse方法进行解析
   doParse(element, parserContext, builder);
   return builder.getBeanDefinition();
}

在自定义标签处理过程中，Spring同样也是按照默认标签的处理方式，包括创建BeanDefinition以及进行默认属性的设置，对于这些工作Spring都默默地帮我们实现了，只是暴露出一些接口来供用户实现个性化的业务。到此为止，我们已经完成过了Spring中的全部的解析工作，也就是Spring将bean从配置文件到加载到内存中的全过程，这么多天的努力终于解析完了BeanFactory xmlBeanFactory = new XmlBeanFactory(new ClassPathResource(“application.xml”))这一句代码，而接下来的任务便是如何使用这些bean，我们在下一篇文章中继续。