Spring源码学习-容器BeanFactory(四) BeanDefinition的创建-自定义标签的解析.md

写在前面

上文Spring源码学习-容器BeanFactory(三) BeanDefinition的创建-解析Spring的默认标签对Spring默认标签的解析做了详解，在xml元素的解析中，Spring的整体思路就是按部就班的读取标签并把数据放入一个map集合中以备后用。

ps:以前在看别人写博客时没有很注意，到自己写才发现：博文一长，如何去维持文章的可读性，让读者在阅读时理清整篇文章的脉络实在是一件很难的事情。上篇文章就是如此，我自己回头去读时都难以去顺畅的学习，何况他人，甚是惭愧。也尝试数次修改，但仍都效果不佳，便放弃了。总归是写博时间太短，功底不足。不过此时也是奔着写自己的读书笔记一样性质的心态。慢慢学习吧，后面会越来越好的。

---

1.5 BeanDefinition的创建 - 处理用户自定义标签

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

接上文，在XML的解析中，Spring获取到一个标签，首先会判断标签类型，如果是Spring定义的默认标签，就使用parseDefaultElement解析，否则就是用户自定义标签，使用parseCustomElement解析。这篇文章就正式进入用户自定义标签的解析。

---

Spring的自定义标签在日常工作中遇到的似乎不多，我也是读到此处源码，顺便学习。具体不再文章中详述，极力推荐在看源码之前参考文章基于Spring开发——自定义标签及其解析对自定义标签的定义有所了解。

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

	public BeanDefinition parseCustomElement(Element ele, BeanDefinition containingBd) {
		//1.获取命名空间URI
		String namespaceUri = getNamespaceURI(ele);
		//2.根据命名空间找到对应的Handle类
		NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
		if (handler == null) {
			error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
			return null;
		}
		//3.使用handle解析标签
		return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
	}

从上面的代码，我们把自定义标签的解析分为三步

• 获取命名空间
• 根据命名空间获取自定义的标签处理类
• 解析自定义标签

命名空间的获取主要使用了W3C的标准DOM处理方式，不多谈，主要看后两步操作。

1.5.1 根据命名空间获取自定义的标签处理类

	public NamespaceHandler resolve(String namespaceUri) {
		//1.获取所有在Spring.handlers注册过的 handle 信息
		Map<String, Object> handlerMappings = getHandlerMappings();
		Object handlerOrClassName = handlerMappings.get(namespaceUri);
		if (handlerOrClassName == null) {
			return null;
		}
		else if (handlerOrClassName instanceof NamespaceHandler) {
			//2.已经被初始化，直接返回对象
			return (NamespaceHandler) handlerOrClassName;
		}
		else {
			//3.还没有被初始化，调用反射方法初始化
			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);
				//调用handle自定义的init()方法
				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);
			}
		}
	}

1. 首先通过Spring.handler配置文件获取命名空间与对应的handle类的映射集合，其方法如下:

   	private Map<String, Object> getHandlerMappings() {
   		//典型的单例对象初始化
   		if (this.handlerMappings == null) {
   			synchronized (this) {
   				if (this.handlerMappings == null) {
   					try {
   						Properties mappings =
   								PropertiesLoaderUtils.loadAllProperties(this.handlerMappingsLocation, this.classLoader);
   						if (logger.isDebugEnabled()) {
   							logger.debug("Loaded NamespaceHandler mappings: " + mappings);
   						}
   						Map<String, Object> handlerMappings = new ConcurrentHashMap<String, Object>(mappings.size());
   						CollectionUtils.mergePropertiesIntoMap(mappings, handlerMappings);
   						this.handlerMappings = handlerMappings;
   					}
   					catch (IOException ex) {
   						throw new IllegalStateException(
   								"Unable to load NamespaceHandler mappings from location [" + this.handlerMappingsLocation + "]", ex);
   					}
   				}
   			}
   		}
   		return this.handlerMappings;
   	}
   

2. 如果该处理类已经被初始化，直接返回，否则调用反射进行初始化。值得一说的就是在创建对象后，立刻调用了处理类的init()方法。使用上述的介绍自定义标签文章的一段代码，帮助我们理解这一步是干嘛的。

   	public class BusinessFlowNamespaceHandlerSupport extends NamespaceHandlerSupport {
   	    public void init() {
   	        //注册用于解析<bf:stop>的解析器
   	        registerBeanDefinitionParser("stop", new BusinessFlowBeanDefinitionParser());
   	    }
   	}
   

执行init方法后，标签对应的解析器就成功被注册了。

1.5.2 解析标签

public final BeanDefinition parse(Element element, ParserContext parserContext) {
	//1.通过解析器初步解析标签
	AbstractBeanDefinition definition = parseInternal(element, parserContext);
	//2.后续处理完善
	if (definition != null && !parserContext.isNested()) {
		try {
			//解析id
			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);
			}
			//解析alias
			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;
}

有了Spirng默认标签解析学习的基础，这里的逻辑看起来简单了很多，后面的id/alias以及监听器的激活不再多讲，我们把目光集中于parseInternal()。

protected final AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
		BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();
		//父元素
		String parentName = getParentName(element);
		if (parentName != null) {
			builder.getRawBeanDefinition().setParentName(parentName);
		}
		//class元素
		Class<?> beanClass = getBeanClass(element);
		if (beanClass != null) {
			builder.getRawBeanDefinition().setBeanClass(beanClass);
		}
		else {
			String beanClassName = getBeanClassName(element);
			if (beanClassName != null) {
				builder.getRawBeanDefinition().setBeanClassName(beanClassName);
			}
		}
		//根据父标签的scope和lazy-init确定此标签属性
		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();
	}

是否感觉一切似曾相识，这里与Spring默认标签的解析也差不太多，Spring在调用我们自定义解析之前，帮我们把一些默认的属性都已经处理完毕了。

---

至此Spring读取配置文件至内存的所有逻辑已经阅读完毕了，接下来就是Bean对象真正创建的过程，下篇文章再见吧。