spring-mvc源码-bean定义加载-默认标签解析(bean)

接上篇：bean定义加载整体流程：https://blog.csdn.net/matt8/article/details/106352083

看下默认命名空间标签的解析过程，也就是http://www.springframework.org/schema/beans命名空间下标签的解析过程。

bean标签的解析是从org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader#parseDefaultElement这个方法开始的，源码如下：

	private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
        //处理 <import> 标签，将资源进行合并再统一解析
		if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
			importBeanDefinitionResource(ele);
		}
        //处理 <alias> 标签
		else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
			processAliasRegistration(ele);
		}
        //处理 <bean> 标签
		else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
			processBeanDefinition(ele, delegate);
		}
        //处理 <beans> 标签，回到开始解析 document 的地方
		else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
			// recurse
			doRegisterBeanDefinitions(ele);
		}
	}

上面的代码很简单，主要是对默认命名空间下支持的import、beans、alias、bean标签的解析处理，我们先看下bean标签的处理方法org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader#processBeanDefinition

	protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
		//委托delegate来完成解析过程，并返回BeanDefinitionHolder对象，该对象存储了BeanDefinition的基本信息
		BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);

		if (bdHolder != null) {
			//委托delegate来完成bdHolder修饰过程
			bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
			try {
				//装饰后的bdHolder注册到容器
				BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
			}
			catch (BeanDefinitionStoreException ex) {
				getReaderContext().error("Failed to register bean definition with name '" +
						bdHolder.getBeanName() + "'", ele, ex);
			}
			//发送注册事件
			getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
		}
	}

接着看bean的解析过程，调用org.springframework.beans.factory.xml.BeanDefinitionParserDelegate#parseBeanDefinitionElement(org.w3c.dom.Element)这个方法，这个方法直接调用的parseBeanDefinitionElement(ele, null)，源码如下：

	public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
		//取得 <bean> 标签的 id 属性
		String id = ele.getAttribute(ID_ATTRIBUTE);
		//取得 <bean> 标签的 name 属性
		String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

		//创建 List 用于存 alias（别名）集合
		List<String> aliases = new ArrayList<String>();
		if (StringUtils.hasLength(nameAttr)) {
			//将 nameArr 按照（,）或（;）分割成数组
			String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
			//添加到别名集合
			aliases.addAll(Arrays.asList(nameArr));
		}

		//判断 id 是否为空，若为空则取别名集合的第一个元素当作 id ，并将其从别名集合当中移除
		String beanName = id;
		if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
			beanName = aliases.remove(0);
			if (logger.isDebugEnabled()) {
				logger.debug("No XML 'id' specified - using '" + beanName +
						"' as bean name and " + aliases + " as aliases");
			}
		}

		// 检查 beanName 是否已经被使用
		if (containingBean == null) {
			checkNameUniqueness(beanName, aliases, ele);
		}

		//解析 <bean> 标签的属性以及相关特性标签，并将其添加进 beanDefinition 返回
		AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
		if (beanDefinition != null) {
			//判断是否存在 beanName
			if (!StringUtils.hasText(beanName)) {
				try {
					if (containingBean != null) {
						beanName = BeanDefinitionReaderUtils.generateBeanName(
								beanDefinition, this.readerContext.getRegistry(), true);
					}
					else {
						//由 Spring 自动生成 beanName
						beanName = this.readerContext.generateBeanName(beanDefinition);
						//取得 bean 的完整类名
						String beanClassName = beanDefinition.getBeanClassName();
						//将 beanClassName 添加进 alais 集合
						if (beanClassName != null &&
								beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
								!this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
							aliases.add(beanClassName);
						}
					}
					if (logger.isDebugEnabled()) {
						logger.debug("Neither XML 'id' nor 'name' specified - " +
								"using generated bean name [" + beanName + "]");
					}
				}
				catch (Exception ex) {
					error(ex.getMessage(), ele);
					return null;
				}
			}
			String[] aliasesArray = StringUtils.toStringArray(aliases);
			//返回一个 BeanDefinitionHolder 实例
			return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
		}

		return null;
	}

再往里看解析bean标签的属性及相关特性的方法是parseBeanDefinitionElement(ele, beanName, containingBean)，源码如下：

	public AbstractBeanDefinition parseBeanDefinitionElement(
			Element ele, String beanName, BeanDefinition containingBean) {

		//入栈操作，往 parseState 中添加一个 新建的 BeanEntry
		this.parseState.push(new BeanEntry(beanName));

		//取得 <bean> 标签的 class 属性
		String className = null;
		if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
			className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
		}

		try {
			//取得 <bean> 标签的 parent 属性
			String parent = null;
			if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
				parent = ele.getAttribute(PARENT_ATTRIBUTE);
			}
			//根据 class，parent 的属性值创建一个 BeanDefinition
			AbstractBeanDefinition bd = createBeanDefinition(className, parent);

			// 取得 <bean> 标签的其他属性，并添加进 BeanDefinition 。如：
	        // scope、
	        // lazy-init
	        // autowire
	        // primary、autowire-candidate
	        // depends-on、dependency-check
	        // init-method、destroy-method
	        // factory-method、factory-bean
			parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
			bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));

			//解析 <mate> 标签
			parseMetaElements(ele, bd);
			//解析 <lookup-method> 标签
			parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
			//解析 <replaced-method> 标签
			parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

			//解析 <constructor-arg> 标签
			parseConstructorArgElements(ele, bd);
			//解析 <property> 标签
			parsePropertyElements(ele, bd);
			//解析 <qualifier> 标签
			parseQualifierElements(ele, bd);

			bd.setResource(this.readerContext.getResource());
			bd.setSource(extractSource(ele));

			return bd;
		}
		catch (ClassNotFoundException ex) {
			error("Bean class [" + className + "] not found", ele, ex);
		}
		catch (NoClassDefFoundError err) {
			error("Class that bean class [" + className + "] depends on not found", ele, err);
		}
		catch (Throwable ex) {
			error("Unexpected failure during bean definition parsing", ele, ex);
		}
		finally {
			this.parseState.pop();
		}

		return null;
	}

至此，一个bean标签便解析完了，解析完拿到BeanDefinitionHolder bdHolder这个之后，会调delegate.decorateBeanDefinitionIfRequired(ele, bdHolder)这个方法，对bdHolder做一次装饰处理，主要场景是：

1、attr属性命名空间与bean命名空间不一致

<!--外部命名空间为bean  内部却为p-->
<bean id="viewResolver" p:prefix="/WEB-INF/view/" p:suffix=".jsp"/>

2、子标签内外命名空间不一致

<bean>
        <！-- 外部为bean命名空间，内部为task命名空间-->
        <task:scheduler id=""/>
</bean>

装饰处理的主要逻辑是找到对应命名空间的处理器，对这些标签做解析，并将这些标签的信息补充到BeanDefinitionHolder bdHolder中，处理完这一步后，就可以注册bean信息到容器中了，通过org.springframework.beans.factory.support.BeanDefinitionReaderUtils#registerBeanDefinition这个方法，源码如下：

	public static void registerBeanDefinition(
			BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
			throws BeanDefinitionStoreException {

		String beanName = definitionHolder.getBeanName();
		//调用容器的注册bean方法，将bean信息注册到容器
		registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

		// Register aliases for bean name, if any.
		String[] aliases = definitionHolder.getAliases();
		if (aliases != null) {
			for (String alias : aliases) {
				//别名注册到容器
				registry.registerAlias(beanName, alias);
			}
		}
	}

至此，一个bean的解析就完成了