Spring源码深度解析系列——bean标签解析《一》

导语

在上一篇文章Spring源码深度解析系列——Bean的基本实现中,阐述了bean的加载、xml的验证模式、以及文件的获取等。但这还只是一个开始,在我们获取到文件后,且进行验证之后,我们便需要对这样的文件进行解析的工作了。所以,本篇文章将开始文件解析的代码讲解。

在Spring中对于标签有默认标签和自定义标签这两种,但这两种方式的用法和解析是存在很大区别的,本篇文章将只针对默认标签和大家进行分享。对于默认标签的解析是在 parseDefaultElement(ele, delegate) 方法中进行操作的,在这个方法中是分别对四种标签(import、alias、bean、bean)进行了不同的处理,代码如下:

	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标签的处理
		else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
			// recurse
			doRegisterBeanDefinitions(ele);
		}
	}

Bean标签的解析

在上面所说的四种标签中,bean标签的解析是最复杂的,也是最重要的。所以这里我们先对bean标签进行分析,当把这个硬骨头啃完了,其他的标签也就可以轻松的解决了,说这么多,我们来先看看bean解析的方法 processBeanDefinition(ele, delegate)中的具体过程:

	protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
		// 进行元素解析
		BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
		// 如果不为空,说明还有自定义的标签,然后对其进行解析
		if (bdHolder != null) {
			bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
			try {
				// Register the final decorated instance.
				// 注册bdHolder
				BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
			}
			catch (BeanDefinitionStoreException ex) {
				getReaderContext().error("Failed to register bean definition with name '" +
						bdHolder.getBeanName() + "'", ele, ex);
			}
			// Send registration event.
			// 发出响应事件,通知相关的监听程序,这个Bean已经记载完成
			getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
		}
	}

首先来给大家提一张时区图,等下配合这张时序图,顺便描述一下具体的逻辑步骤,图如下:

Spring源码深度解析系列——bean标签解析《一》

从上面的代码中和时序图中可以看出,这个方法的具体逻辑大概如:

  1. 首先委托 BeanDefinitionParserDelegate 这个类的 parseBeanDefinitionElement(ele) 方法对元素进行解析,然后返回BeanDefinitionHolder 实例 bdHolder,在经过这个方法解析后,bdHolder便已经包含了配置文件中的各种属性,如:class、name、id、alias。
  2. 在返回的 bdHolder 不为 null 的情况下,如果还存在默认标签的子节点下存在自定义标签,那就还需要对自定义标签进行解析。
  3. 在解析完成后,还需要对解析后的 bdHolder 进行注册,同样的,注册操作委托给了 BeanDefinitionReaderUtils 这个类的registerBeanDefinition(bdHolder, getReaderContext().getRegistry()) 方法。
  4. 在上面所有步骤的工作完成后,便会通知相关的监听器,通知这个bean已经注册完成了。

1.解析BeanDefinition

上面对bean标签这样一个基本的工作流程进行简单的阐述后,现在就需要对每个具体的操作进行解析了,这里首先要从元素的解析和信息的提取开始讲起,就是上面所阐述的步骤中第一步中所提到的parseBeanDefinitionElement(ele),进入这个方法代码如下:

	public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
		return parseBeanDefinitionElement(ele, null);
	}
	public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
		// 解析id属性
		String id = ele.getAttribute(ID_ATTRIBUTE);
		// 解析那么属性
		String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

		List<String> aliases = new ArrayList<>();
		// 分割name属性
		if (StringUtils.hasLength(nameAttr)) {
			String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
			aliases.addAll(Arrays.asList(nameArr));
		}

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

		if (containingBean == null) {
			checkNameUniqueness(beanName, aliases, ele);
		}

		// 第二步
		AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
		if (beanDefinition != null) {
			if (!StringUtils.hasText(beanName)) {
				try {
					// 如果不存在beanName,那么根据Spring中提供的命名规则为当前Bean生成对应的beanName
					if (containingBean != null) {
						beanName = BeanDefinitionReaderUtils.generateBeanName(
								beanDefinition, this.readerContext.getRegistry(), true);
					}
					else {
						beanName = this.readerContext.generateBeanName(beanDefinition);
						String beanClassName = beanDefinition.getBeanClassName();
						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);
			return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
		}

		return null;
	}

上述代码中所体现的就是标签的整个解析的流程,虽然这里只能看到对属性id、name的解析,但从这里已能观其大概了。这段代码的大体流程如下:

  1. 首先,提取id、name的属性。
  2. 然后进一步解析其他的属性,并统一封装到 GenericBeanDefinition 中。
  3. 如果检测到了bean 没有指定beanName,那么就用默认的规则实现beanName。
  4. 最后将获取到的信息封装到 BeanDefinitionHolder 中。

对于上面步骤中的步骤二,其实就是 AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean) ,代码如下:

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

		this.parseState.push(new BeanEntry(beanName));

		String className = null;
		// 解析class属性
		if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
			className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
		}
		String parent = null;
		// 解析parent属性
		if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
			parent = ele.getAttribute(PARENT_ATTRIBUTE);
		}

		try {
			// 创建用于承载属性的AbstractBeanDefinition类型的GenericBeanDefinition
			AbstractBeanDefinition bd = createBeanDefinition(className, parent);

			// 硬编码解析默认Bean的各种属性
			parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
			// 提取description
			bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));

			// 解析元数据
			parseMetaElements(ele, bd);
			// 解析lookup-method属性
			parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
			// 解析replace-method属性
			parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

			// 解析构造函数参数
			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标签的所有的属性了,虽然步骤比较繁杂,但条理清晰,这样的核心代码其实能给我们更多的兴趣去研读。接下来便是复杂的标签属性解析之旅了。

2.承载性BeanDefinition的创建

从前面的代码中,我们可以看到方法中传入了 BeanDefinition 这样一个参数,其实 BeanDefinition 只是一个接口,在Spring中有三种实现:RootBeanDefinition、ChildBeanDefinition、GenericBeanDefinition,而这三种实现又都继承自AbstractBeanDefinition。

其实BeanDefinition是配置文件<bean>元素标签在容器内部的表现形式,在<bean>元素标签中有class、scope、lazy-init等配置属性,而BeanDefinition中则提供了beanClass、scope、lazyInit属性,和<bean>元素标签中的属性是一一对应的。上面提到的三种实现类,其中RootBeanDefinition是最常用到的,它是对应一般的<bean>元素标签,而GenericBeanDefinition是在Spring2.5版本以后才新添加的bean文件配置属性定义类,是一站式服务类。

在配置文件中是可以定义父类bean和子类bean的,父类bean就用RootBeanDefinition表示,反之则用ChildBeanDefinition表示,如果没有父类bean的bean还使用RootBeanDefinition来表示,而AbstractBeanDefinition是需两者共同的信息进行抽象的。

在Spring中是通BeanDefinition把配置文件中的<bean>元素标签转换到容器内部来表示,转换完成后还要将BeanDefinition注册到BeanDefinitionRegistry中,Spring中的BeanDefinitionRegistry类似是Spring配置文件的内存数据库,主要是以map的形式保存,这样在后续操作中就可以直接从BeanDefinitionRegistry中读取配置信息。

其实要解析属性,那么肯定要先创建用于承载属性的实例,也就是创建GenericBeanDefinition,而上面代码中的createBeanDefinition(className, parent)方法就是有此作用的,代码如下:

	protected AbstractBeanDefinition createBeanDefinition(@Nullable String className, @Nullable String parentName)
			throws ClassNotFoundException {

		return BeanDefinitionReaderUtils.createBeanDefinition(
				parentName, className, this.readerContext.getBeanClassLoader());
	}
	public static AbstractBeanDefinition createBeanDefinition(
			@Nullable String parentName, @Nullable String className, @Nullable ClassLoader classLoader) throws ClassNotFoundException {

		GenericBeanDefinition bd = new GenericBeanDefinition();
		// parentName可能为空
		bd.setParentName(parentName);
		if (className != null) {
			if (classLoader != null) {
				// 如果classLoader不为空,则使用以传入的classLoader同一虚拟机加载类对象,否则只是记录className
				bd.setBeanClass(ClassUtils.forName(className, classLoader));
			}
			else {
				bd.setBeanClassName(className);
			}
		}
		return bd;
	}

3.解析属性

上面的代码就是创建承载性的实例,那么创建完后,我们便可以对bean信息中的属性进行解析了,首先我们来看看 parseBeanDefinitionAttributes(ele, beanName, containingBean, bd)这个方法,这个方法是解析element中所有元素的属性的:

	public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,
			@Nullable BeanDefinition containingBean, AbstractBeanDefinition bd) {

		// 在以前的版本中这里是解析singleton属性的,但是作为新版本已经兼并到scope中了
		if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {
			error("Old 1.x 'singleton' attribute in use - upgrade to 'scope' declaration", ele);
		}
		// 解析scope属性
		else if (ele.hasAttribute(SCOPE_ATTRIBUTE)) {
			bd.setScope(ele.getAttribute(SCOPE_ATTRIBUTE));
		}
		else if (containingBean != null) {
			// Take default from containing bean in case of an inner bean definition.
			// 在嵌入BeanDefinition的情况下,且没有单独指定scope属性,则使用父类默认的属性
			bd.setScope(containingBean.getScope());
		}

		// 解析abstract属性
		if (ele.hasAttribute(ABSTRACT_ATTRIBUTE)) {
			bd.setAbstract(TRUE_VALUE.equals(ele.getAttribute(ABSTRACT_ATTRIBUTE)));
		}

		// 解析lazy-init属性
		String lazyInit = ele.getAttribute(LAZY_INIT_ATTRIBUTE);
		if (isDefaultValue(lazyInit)) {
			lazyInit = this.defaults.getLazyInit();
		}
		// 若没有设置或设置其他字符都会被设置为false
		bd.setLazyInit(TRUE_VALUE.equals(lazyInit));

		// 解析autowire属性
		String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);
		bd.setAutowireMode(getAutowireMode(autowire));

		// 解析depends-on属性
		if (ele.hasAttribute(DEPENDS_ON_ATTRIBUTE)) {
			String dependsOn = ele.getAttribute(DEPENDS_ON_ATTRIBUTE);
			bd.setDependsOn(StringUtils.tokenizeToStringArray(dependsOn, MULTI_VALUE_ATTRIBUTE_DELIMITERS));
		}

		// 解析autowire-candidate属性
		String autowireCandidate = ele.getAttribute(AUTOWIRE_CANDIDATE_ATTRIBUTE);
		if (isDefaultValue(autowireCandidate)) {
			String candidatePattern = this.defaults.getAutowireCandidates();
			if (candidatePattern != null) {
				String[] patterns = StringUtils.commaDelimitedListToStringArray(candidatePattern);
				bd.setAutowireCandidate(PatternMatchUtils.simpleMatch(patterns, beanName));
			}
		}
		else {
			bd.setAutowireCandidate(TRUE_VALUE.equals(autowireCandidate));
		}

		// 解析primary属性
		if (ele.hasAttribute(PRIMARY_ATTRIBUTE)) {
			bd.setPrimary(TRUE_VALUE.equals(ele.getAttribute(PRIMARY_ATTRIBUTE)));
		}
		// 解析init-method属性
		if (ele.hasAttribute(INIT_METHOD_ATTRIBUTE)) {
			String initMethodName = ele.getAttribute(INIT_METHOD_ATTRIBUTE);
			bd.setInitMethodName(initMethodName);
		}
		else if (this.defaults.getInitMethod() != null) {
			bd.setInitMethodName(this.defaults.getInitMethod());
			bd.setEnforceInitMethod(false);
		}

		// 解析destroy-method属性
		if (ele.hasAttribute(DESTROY_METHOD_ATTRIBUTE)) {
			String destroyMethodName = ele.getAttribute(DESTROY_METHOD_ATTRIBUTE);
			bd.setDestroyMethodName(destroyMethodName);
		}
		else if (this.defaults.getDestroyMethod() != null) {
			bd.setDestroyMethodName(this.defaults.getDestroyMethod());
			bd.setEnforceDestroyMethod(false);
		}

		// 解析factory-method属性
		if (ele.hasAttribute(FACTORY_METHOD_ATTRIBUTE)) {
			bd.setFactoryMethodName(ele.getAttribute(FACTORY_METHOD_ATTRIBUTE));
		}
		// 解析factory-bean-method属性
		if (ele.hasAttribute(FACTORY_BEAN_ATTRIBUTE)) {
			bd.setFactoryBeanName(ele.getAttribute(FACTORY_BEAN_ATTRIBUTE));
		}

		return bd;
	}

在这段代码中,可以清楚地看到Spring实行了个bean的各种属性进行解析的操作,这些属性中有很多是平常常用的。

4.解析各类子元素

(1).解析子元素meta

在看代码之前先来看看meta属性的使用。

    <bean id="studengt" class="com.zfy.spring.test.bean.Student">
        <meta key="test" value="test"/>
    </bean>

  这里的代码并不会体现在Student中,只是一个额外的声明,当需要使用其中的信息的时候,可以通过BeanDefinition的getAttribute(key)的方法进行获取。

	public void parseMetaElements(Element ele, BeanMetadataAttributeAccessor attributeAccessor) {
		// 获取当前节点所有子元素
		NodeList nl = ele.getChildNodes();
		for (int i = 0; i < nl.getLength(); i++) {
			Node node = nl.item(i);
			// 获取meta
			if (isCandidateElement(node) && nodeNameEquals(node, META_ELEMENT)) {
				Element metaElement = (Element) node;
				String key = metaElement.getAttribute(KEY_ATTRIBUTE);
				String value = metaElement.getAttribute(VALUE_ATTRIBUTE);
				// 使用key、value构造BeanMetadataAttribute
				BeanMetadataAttribute attribute = new BeanMetadataAttribute(key, value);
				attribute.setSource(extractSource(metaElement));
				// 记录信息
				attributeAccessor.addMetadataAttribute(attribute);
			}
		}
	}

(2).解析lookup-method

其实平常我们也是很少使用lookuo-method,但是它却是非常有用的属性,通常称其为获取器注入。在Spring In Action一书中有这么一句话:获取器注入是一种特殊的方法注入,它是把一个方法声明为返回某种类型的bean,但实际上要返回的bean是在配置文件里配置的,此方法可用在设计有些可插拔的功能上,我们来看看他具体的应用:

1.父类

public class User {
    public void showMe() {
        System.out.println("I am User!");
    }
}

 2.子类覆盖父类

public class Teacher extends User {
    public void showMe() {
        System.out.println("I am teacher!");
    }
}

3.创建调用类

public abstract class GetBeanTest {
    public  void showMe() {
        this.getBean().showMe();
    }
    public abstract User getBean();
}

 5.测试类

public class Main {
    public static void main(String[] args) {
        ApplicationContext bf = new ClassPathXmlApplicationContext("lookupTest.xml");
        GetBeanTest test = (GetBeanTest) bf.getBean("getBeanTest");
        test.showMe();
    }
}

6. 配置文件

    <bean id="getBeanTest" class="com.zfy.spring.test.bean.GetBeanTest">
        <lookup-method name="getBean" bean="teacher" />
    </bean>
    <bean id="teacher" class="com.zfy.spring.test.bean.Teacher" />

从上面的实例使用中,可以看出lookup-method子元素提供的大致功能,那么来看看源码具体实现:

	public void parseLookupOverrideSubElements(Element beanEle, MethodOverrides overrides) {
		NodeList nl = beanEle.getChildNodes();
		for (int i = 0; i < nl.getLength(); i++) {
			Node node = nl.item(i);
			// 仅当在Spring默认bean写子元素下且为 <look-method 时有效
			if (isCandidateElement(node) && nodeNameEquals(node, LOOKUP_METHOD_ELEMENT)) {
				Element ele = (Element) node;
				// 获取需要修饰的方法
				String methodName = ele.getAttribute(NAME_ATTRIBUTE);
				// 获取配置返回的bean
				String beanRef = ele.getAttribute(BEAN_ELEMENT);
				LookupOverride override = new LookupOverride(methodName, beanRef);
				override.setSource(extractSource(ele));
				overrides.addOverride(override);
			}
		}
	}

 从上面代码中可以看出和parseMetaElements方法不过是大同小异,最大的区别就是在if判断中的节点名称在这里叫LOOKUP_METHOD_ELEMENT。还有数据存储是通过LookupOverride去承载并记录在AbstractBeanDefinition中的methodOverride属性中的。

(3).解析replace-method

这个方法主要的作用是对bean中的replace-method子元素的提取,这个子元素的主要作用就是:可以才运行时用心的方法替换现有的方法 ,与之前的look-up不同的是,replace-method不但可以动态的替换返回实体bean,而且可以动态的更改原有方法的逻辑。

	public void parseReplacedMethodSubElements(Element beanEle, MethodOverrides overrides) {
		NodeList nl = beanEle.getChildNodes();
		for (int i = 0; i < nl.getLength(); i++) {
			Node node = nl.item(i);
			// 仅当在Spring默认bean写子元素下且为 <replaced-method 时有效
			if (isCandidateElement(node) && nodeNameEquals(node, REPLACED_METHOD_ELEMENT)) {
				Element replacedMethodEle = (Element) node;
				// 提取要替换的旧的方法
				String name = replacedMethodEle.getAttribute(NAME_ATTRIBUTE);
				// 提取对应的新的替换方法
				String callback = replacedMethodEle.getAttribute(REPLACER_ATTRIBUTE);
				ReplaceOverride replaceOverride = new ReplaceOverride(name, callback);
				// Look for arg-type match elements.
				List<Element> argTypeEles = DomUtils.getChildElementsByTagName(replacedMethodEle, ARG_TYPE_ELEMENT);
				for (Element argTypeEle : argTypeEles) {
					// 记录参数
					String match = argTypeEle.getAttribute(ARG_TYPE_MATCH_ATTRIBUTE);
					match = (StringUtils.hasText(match) ? match : DomUtils.getTextValue(argTypeEle));
					if (StringUtils.hasText(match)) {
						replaceOverride.addTypeIdentifier(match);
					}
				}
				replaceOverride.setSource(extractSource(replacedMethodEle));
				overrides.addOverride(replaceOverride);
			}
		}
	}

(4).解析子元素construct-arg

	public void parseConstructorArgElements(Element beanEle, BeanDefinition bd) {
		NodeList nl = beanEle.getChildNodes();
		for (int i = 0; i < nl.getLength(); i++) {
			Node node = nl.item(i);
			if (isCandidateElement(node) && nodeNameEquals(node, CONSTRUCTOR_ARG_ELEMENT)) {
				// 解析constructor-arg
				parseConstructorArgElement((Element) node, bd);
			}
		}
	}

 

	public void parseConstructorArgElement(Element ele, BeanDefinition bd) {
		// 提取index属性
		String indexAttr = ele.getAttribute(INDEX_ATTRIBUTE);
		// 提取type属性
		String typeAttr = ele.getAttribute(TYPE_ATTRIBUTE);
		// 提取那么属性
		String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
		if (StringUtils.hasLength(indexAttr)) {
			try {
				int index = Integer.parseInt(indexAttr);
				if (index < 0) {
					error("'index' cannot be lower than 0", ele);
				}
				else {
					try {
						this.parseState.push(new ConstructorArgumentEntry(index));
						// 解析ele对应的属性元素
						Object value = parsePropertyValue(ele, bd, null);
						// 封装解析出来的数据
						ConstructorArgumentValues.ValueHolder valueHolder = new ConstructorArgumentValues.ValueHolder(value);
						if (StringUtils.hasLength(typeAttr)) {
							valueHolder.setType(typeAttr);
						}
						if (StringUtils.hasLength(nameAttr)) {
							valueHolder.setName(nameAttr);
						}
						valueHolder.setSource(extractSource(ele));
						// 不允许重复指定相同参数
						if (bd.getConstructorArgumentValues().hasIndexedArgumentValue(index)) {
							error("Ambiguous constructor-arg entries for index " + index, ele);
						}
						else {
							bd.getConstructorArgumentValues().addIndexedArgumentValue(index, valueHolder);
						}
					}
					finally {
						this.parseState.pop();
					}
				}
			}
			catch (NumberFormatException ex) {
				error("Attribute 'index' of tag 'constructor-arg' must be an integer", ele);
			}
		}
		else {
			// 没有index,就忽略去属性,自动寻找
			try {
				this.parseState.push(new ConstructorArgumentEntry());
				Object value = parsePropertyValue(ele, bd, null);
				ConstructorArgumentValues.ValueHolder valueHolder = new ConstructorArgumentValues.ValueHolder(value);
				if (StringUtils.hasLength(typeAttr)) {
					valueHolder.setType(typeAttr);
				}
				if (StringUtils.hasLength(nameAttr)) {
					valueHolder.setName(nameAttr);
				}
				valueHolder.setSource(extractSource(ele));
				bd.getConstructorArgumentValues().addGenericArgumentValue(valueHolder);
			}
			finally {
				this.parseState.pop();
			}
		}
	}

 上面这段代码还是很复杂的,但逻辑也是还是比较清晰的,首先是提取constructor-arg上的重要属性(index、type、name)。

  • 如果配置中指定了index属性,此时操作如下:
    1. 解析constructor-arg的子元素
    2. 使用ConstructorArgumentValus.ValueHolder类型来封装解析出来的元素。
    3. 将type、name、index属性一起封装到ConstructorArgumentValus.ValueHolder中,并添加到BeanDefinition的constructorArgumentValues的indexArgumentValues属性中。
  • 如果没有指定index,操作如下:
    1. 解析constructor-arg的子元素
    2. 使用ConstructorArgumentValus.ValueHolder类型来封装解析出来的元素。
    3. 将type、name、index属性一起封装到ConstructorArgumentValus.ValueHolder中,并添加到BeanDefinition的constructorArgumentValues的genericArgumentValues属性中。

由此得知,对于是否指定了index,Spring是有不同的解决方法的,关键是属性信息保存的位置。在了解完上面的整个流程后,那么来继续看看解析子元素的过程,来看看 parsePropertyValue(ele, bd, propertyName)这个方法:

	public Object parsePropertyValue(Element ele, BeanDefinition bd, @Nullable String propertyName) {
		String elementName = (propertyName != null ?
				"<property> element for property '" + propertyName + "'" :
				"<constructor-arg> element");

		// Should only have one child element: ref, value, list, etc.
		// 获取一个属性只能对应的一种类型:ref、value、list等
		NodeList nl = ele.getChildNodes();
		Element subElement = null;
		for (int i = 0; i < nl.getLength(); i++) {
			Node node = nl.item(i);
			// 对应description或者meta不处理
			if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT) &&
					!nodeNameEquals(node, META_ELEMENT)) {
				// Child element is what we're looking for.
				if (subElement != null) {
					error(elementName + " must not contain more than one sub-element", ele);
				}
				else {
					subElement = (Element) node;
				}
			}
		}

		// 解析constructor-arg上的ref属性
		boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE);
		// 解析constructor-arg上的value属性
		boolean hasValueAttribute = ele.hasAttribute(VALUE_ATTRIBUTE);
		/**
		 * 在constructor-arg上不存在:
		 * 		1.同时既有ref属性又有value属性
		 * 		2.存在ref属性或者value属性又有子元素
		 */
		if ((hasRefAttribute && hasValueAttribute) ||
				((hasRefAttribute || hasValueAttribute) && subElement != null)) {
			error(elementName +
					" is only allowed to contain either 'ref' attribute OR 'value' attribute OR sub-element", ele);
		}

		if (hasRefAttribute) {
			// ref属性的处理,使用RuntimeBeanReference封装对应的ref
			String refName = ele.getAttribute(REF_ATTRIBUTE);
			if (!StringUtils.hasText(refName)) {
				error(elementName + " contains empty 'ref' attribute", ele);
			}
			RuntimeBeanReference ref = new RuntimeBeanReference(refName);
			ref.setSource(extractSource(ele));
			return ref;
		}
		else if (hasValueAttribute) {
			// value属性的处理,使用TypeStringValue封装
			TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE));
			valueHolder.setSource(extractSource(ele));
			return valueHolder;
		}
		else if (subElement != null) {
			// 解析子元素
			return parsePropertySubElement(subElement, bd);
		}
		else {
			// Neither child element nor "ref" or "value" attribute found.
			// 既没有ref,也没有value,也没有子元素,那就来个报错玩玩吧!
			error(elementName + " must specify a ref or value", ele);
			return null;
		}
	}

上面代码大概经过以下几个过程:

  1. 忽略过description或者meta
  2. 提取constructor-arg上的ref和value属性,以便更久规则验证正确性,其规则为在 constructor-arg上不存在以下情况。
    • 同时既有ref又有value属性
    • 存在ref属性或者value属性,且还有子元素
  3. ref属性的处理,使用RuntimeBeanReferance封装对应的ref名称,如:<constructor-arg ref=“aa”>
  4. value属性的梳理使用TypeStringValue封装,如:<constructor-arg value=“aa”>
  5. 子元素处理,这里对于子元素的处理,提到了在方法中嵌入了子元素的map,具体实现如下:
	public Object parsePropertySubElement(Element ele, @Nullable BeanDefinition bd) {
		return parsePropertySubElement(ele, bd, null);
	}



	public Object parsePropertySubElement(Element ele, @Nullable BeanDefinition bd, @Nullable String defaultValueType) {
		if (!isDefaultNamespace(ele)) {
			return parseNestedCustomElement(ele, bd);
		}
		else if (nodeNameEquals(ele, BEAN_ELEMENT)) {
			BeanDefinitionHolder nestedBd = parseBeanDefinitionElement(ele, bd);
			if (nestedBd != null) {
				nestedBd = decorateBeanDefinitionIfRequired(ele, nestedBd, bd);
			}
			return nestedBd;
		}
		else if (nodeNameEquals(ele, REF_ELEMENT)) {
			// A generic reference to any name of any bean.
			String refName = ele.getAttribute(BEAN_REF_ATTRIBUTE);
			boolean toParent = false;
			if (!StringUtils.hasLength(refName)) {
				// A reference to the id of another bean in a parent context.
				// 解析parent
				refName = ele.getAttribute(PARENT_REF_ATTRIBUTE);
				toParent = true;
				if (!StringUtils.hasLength(refName)) {
					error("'bean' or 'parent' is required for <ref> element", ele);
					return null;
				}
			}
			if (!StringUtils.hasText(refName)) {
				error("<ref> element contains empty target attribute", ele);
				return null;
			}
			RuntimeBeanReference ref = new RuntimeBeanReference(refName, toParent);
			ref.setSource(extractSource(ele));
			return ref;
		}
		// 对idref元素的解析
		else if (nodeNameEquals(ele, IDREF_ELEMENT)) {
			return parseIdRefElement(ele);
		}
		// 对value子元素的解析
		else if (nodeNameEquals(ele, VALUE_ELEMENT)) {
			return parseValueElement(ele, defaultValueType);
		}
		// 对null子元素的解析
		else if (nodeNameEquals(ele, NULL_ELEMENT)) {
			// It's a distinguished null value. Let's wrap it in a TypedStringValue
			// object in order to preserve the source location.
			TypedStringValue nullHolder = new TypedStringValue(null);
			nullHolder.setSource(extractSource(ele));
			return nullHolder;
		}
		// 解析array子元素
		else if (nodeNameEquals(ele, ARRAY_ELEMENT)) {
			return parseArrayElement(ele, bd);
		}
		// 解析list子元素
		else if (nodeNameEquals(ele, LIST_ELEMENT)) {
			return parseListElement(ele, bd);
		}
		// 解析set子元素
		else if (nodeNameEquals(ele, SET_ELEMENT)) {
			return parseSetElement(ele, bd);
		}
		// 解析map子元素
		else if (nodeNameEquals(ele, MAP_ELEMENT)) {
			return parseMapElement(ele, bd);
		}
		// 解析props子元素
		else if (nodeNameEquals(ele, PROPS_ELEMENT)) {
			return parsePropsElement(ele);
		}
		else {
			error("Unknown property sub-element: [" + ele.getNodeName() + "]", ele);
			return null;
		}
	}

 

 

(5).解析子元素property

	public void parsePropertyElements(Element beanEle, BeanDefinition bd) {
		NodeList nl = beanEle.getChildNodes();
		for (int i = 0; i < nl.getLength(); i++) {
			Node node = nl.item(i);
			if (isCandidateElement(node) && nodeNameEquals(node, PROPERTY_ELEMENT)) {
				parsePropertyElement((Element) node, bd);
			}
		}
	}
	public void parsePropertyElement(Element ele, BeanDefinition bd) {
		// 获取配置元素中的name值
		String propertyName = ele.getAttribute(NAME_ATTRIBUTE);
		if (!StringUtils.hasLength(propertyName)) {
			error("Tag 'property' must have a 'name' attribute", ele);
			return;
		}
		this.parseState.push(new PropertyEntry(propertyName));
		try {
			// 不允许多次对同一属性配置
			if (bd.getPropertyValues().contains(propertyName)) {
				error("Multiple 'property' definitions for property '" + propertyName + "'", ele);
				return;
			}
			Object val = parsePropertyValue(ele, bd, propertyName);
			PropertyValue pv = new PropertyValue(propertyName, val);
			parseMetaElements(ele, pv);
			pv.setSource(extractSource(ele));
			bd.getPropertyValues().addPropertyValue(pv);
		}
		finally {
			this.parseState.pop();
		

 

(6).解析子元素qualifier

对于qualifier元素的获取,平常接触的更多的是注解的形式, 在使用Spring框架中进行自动注入时,Spring容器中在匹配的时候选取Bean的数目的时候,必须有且仅有一个,当找不到一个匹配的Bean的时候,将会抛出BeanCreationException异常,并指出必须至少拥有一个匹配的Bean。

	public void parseQualifierElements(Element beanEle, AbstractBeanDefinition bd) {
		NodeList nl = beanEle.getChildNodes();
		for (int i = 0; i < nl.getLength(); i++) {
			Node node = nl.item(i);
			if (isCandidateElement(node) && nodeNameEquals(node, QUALIFIER_ELEMENT)) {
				parseQualifierElement((Element) node, bd);
			}
		}
	}
	public void parseQualifierElement(Element ele, AbstractBeanDefinition bd) {
		// 获取配置元素中的type值
		String typeName = ele.getAttribute(TYPE_ATTRIBUTE);
		if (!StringUtils.hasLength(typeName)) {
			error("Tag 'qualifier' must have a 'type' attribute", ele);
			return;
		}
		this.parseState.push(new QualifierEntry(typeName));
		try {
			AutowireCandidateQualifier qualifier = new AutowireCandidateQualifier(typeName);
			qualifier.setSource(extractSource(ele));
			// 获取配置元素中的value值
			String value = ele.getAttribute(VALUE_ATTRIBUTE);
			if (StringUtils.hasLength(value)) {
				qualifier.setAttribute(AutowireCandidateQualifier.VALUE_KEY, value);
			}
			// 获取子元素,然后对子元素中的属性进行解析
			NodeList nl = ele.getChildNodes();
			for (int i = 0; i < nl.getLength(); i++) {
				Node node = nl.item(i);
				if (isCandidateElement(node) && nodeNameEquals(node, QUALIFIER_ATTRIBUTE_ELEMENT)) {
					Element attributeEle = (Element) node;
					String attributeName = attributeEle.getAttribute(KEY_ATTRIBUTE);
					String attributeValue = attributeEle.getAttribute(VALUE_ATTRIBUTE);
					if (StringUtils.hasLength(attributeName) && StringUtils.hasLength(attributeValue)) {
						BeanMetadataAttribute attribute = new BeanMetadataAttribute(attributeName, attributeValue);
						attribute.setSource(extractSource(attributeEle));
						qualifier.addMetadataAttribute(attribute);
					}
					else {
						error("Qualifier 'attribute' tag must have a 'name' and 'value'", attributeEle);
						return;
					}
				}
			}
			bd.addQualifier(qualifier);
		}
		finally {
			this.parseState.pop();
		}
	}

 

由于篇幅原因,本篇文章就先写到这里,下一篇文章我们还会继续来解析Bean标签的解析和注册。

 

 

 

 

 

 

 

上一篇:Spring源码剖析1:初探Spring IOC核心流程


下一篇:SQL Server安装教程(超详细)