spring--三自定义标签解析

当完成配置文件到Document的转换并提取对应的root后，将开始所有元素的解析，在这一过程中便开始了默认标签与自定义标签两种格式的区分，函数如下：

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

默认的标签解析使用parseDefaultElement(ele, delegate)，自定义标签的机械使用parseCustomElement(ele)。

一 自定义标签使用

在很多情况下，我们需要为系统提供可配置化支持，简单做法是基于Spring的标准bean来配置，但配置较为复杂或需要更多丰富控制的时候，会显得繁琐。一般的做法是用原生态的方式去解析定义好的XML文件，然后转化为配置对象。这种方式可以解决所有问题，但实现繁琐。Spring提供了可扩展Schema的支持，扩展Spring自定义标签配置大致需要以下步骤：

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

二 自定义标签的解析

下面是自定义标签解析的代码：

@Nullable public BeanDefinition parseCustomElement(Element ele) { return parseCustomElement(ele, null); } @Nullable public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) { //获取名称空间 String namespaceUri = getNamespaceURI(ele); if (namespaceUri == null) { return null; } // 根据名称空间获取NamespaceHandlerResolver() NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri); if (handler == null) { error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele); return null; } //对自定义标签解析 return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd)); }

1 获取标签的命名空间

标签的解析使用命名空间开始，无论是区分默认标签还是自定义标签，都是先提取命名空间，下面是提取命名空间的代码：

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

2 提取自定义标签处理器

有了命名空间就可以对NamespaceHandler提取了，spring中使用NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri)完成NamespaceHandler的提取，其中readerContext初始化时其属性namespaceHandlerResolver被初始化为DefaultNamespaceHandlerResolver实例，这里的resolver()方法是调用的DefaultNamespaceHandlerResolver的方法。

@Override @Nullable public NamespaceHandler resolve(String namespaceUri) { 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.init(); handlerMappings.put(namespaceUri, namespaceHandler); return namespaceHandler; } catch (ClassNotFoundException ex) { throw new FatalBeanException("NamespaceHandler class [" + className + "] for namespace [" + namespaceUri + "] not found", ex); } catch (LinkageError err) { throw new FatalBeanException("Invalid NamespaceHandler class [" + className + "] for namespace [" + namespaceUri + "]: problem with handler class file or dependent class", err); } } }

这个函数清晰解释了解析自定义NamespaceHandler的过程。

首先获取handlerMappings，就是读取spring.handlers配置文件并将其缓存到map中；然后通过namespaceUri，调用handlerMappings.get(namespaceUri)方法获取信息；然后根据返回的信息返回NamespaceHandler。

下面是getHandlerMappings()的代码：

/** * Load the specified NamespaceHandler mappings lazily. */ private Map<String, Object> getHandlerMappings() { Map<String, Object> handlerMappings = this.handlerMappings; if (handlerMappings == null) { synchronized (this) { handlerMappings = this.handlerMappings; if (handlerMappings == null) { try { Properties mappings = PropertiesLoaderUtils.loadAllProperties(this.handlerMappingsLocation, this.classLoader); if (logger.isDebugEnabled()) { logger.debug("Loaded NamespaceHandler mappings: " + mappings); } Map<String, Object> mappingsToUse = new ConcurrentHashMap<>(mappings.size()); CollectionUtils.mergePropertiesIntoMap(mappings, mappingsToUse); handlerMappings = mappingsToUse; this.handlerMappings = handlerMappings; } catch (IOException ex) { throw new IllegalStateException( "Unable to load NamespaceHandler mappings from location [" + this.handlerMappingsLocation + "]", ex); } } } } return handlerMappings; }

3 标签解析

得到要分析的元素和解析器后，spring就将解析工作委托给自定义解析器去解析，下面是代码：

handler.parse(ele, new ParserContext(this.readerContext, this, containingBd))

这个parse()方法是调用的父类方法，代码如下：

/** * Parses the supplied {@link Element} by delegating to the {@link BeanDefinitionParser} that is * registered for that {@link Element}. */ @Override public BeanDefinition parse(Element element, ParserContext parserContext) { return findParserForElement(element, parserContext).parse(element, parserContext); }

由上可知，它先寻找元素对应的解析器，进而调用解析器中的parse()方法。

@Override 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)); } } 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) { parserContext.getReaderContext().error(ex.getMessage(), element); return null; } } return definition; }

由上代码可以看出，大部分代码是用来处理将解析后的AbstractBeanDefinition转化为BeanDefinitonHolder，并注册bean。真正

去完成解析工作委托给了parseInternal(element, parserContext)方法，在这个方法中调用了自定义的解析函数。

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

@Override protected final AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) { BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(); String parentName = getParentName(element); if (parentName != null) { builder.getRawBeanDefinition().setParentName(parentName); } Class<?> beanClass = getBeanClass(element); if (beanClass != null) { builder.getRawBeanDefinition().setBeanClass(beanClass); } else { String beanClassName = getBeanClassName(element); if (beanClassName != null) { builder.getRawBeanDefinition().setBeanClassName(beanClassName); } } builder.getRawBeanDefinition().setSource(parserContext.extractSource(element)); if (parserContext.isNested()) { // Inner bean definition must receive same scope as containing bean. builder.setScope(parserContext.getContainingBeanDefinition().getScope()); } if (parserContext.isDefaultLazyInit()) { // Default-lazy-init applies to custom bean definitions as well. builder.setLazyInit(true); } doParse(element, parserContext, builder); return builder.getBeanDefinition(); }