spring--三 自定义标签解析

于 2019-11-02 14:31:12 发布
阅读量113 收藏
点赞数
分类专栏： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_31583183/article/details/102870923
版权

当完成配置文件到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自定义标签配置大致需要以下步骤：

  1. 创建一个需要扩展的组件；
  2. 定义一个XSD文件描述符；
  3. 创建一个文件，实现BeanDefinitionParser接口，用来解析XSD文件中的定义和组件定义；
  4. 创建一个Handler文件，扩展自NamespaceHandlerSupport，目的是将组件注册到Spring容器；
  5. 编写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的过程。

  1. 首先获取handlerMappings，就是读取spring.handlers配置文件并将其缓存到map中；
  2. 然后通过namespaceUri，调用handlerMappings.get(namespaceUri)方法获取信息；
  3. 然后根据返回的信息返回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();
	}

 

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值