Spring IoC的细节--BeanDefinitionParserDelegate.parseBeanDefinitionElement(Element ele)

最新推荐文章于 2024-06-16 22:55:15 发布

老dubbo

最新推荐文章于 2024-06-16 22:55:15 发布

阅读量631

点赞数 2

分类专栏： Spring IoC细节文章标签： Spring IoC初始化细节

本文链接：https://blog.youkuaiyun.com/aidaowuqiong/article/details/102741376

版权

Spring IoC细节专栏收录该内容

16 篇文章

订阅专栏

本文详细探讨了Spring IoC初始化过程中的BeanDefinition解析，主要关注BeanDefinitionParserDelegate的parseBeanDefinitionElement方法。通过代码分析，展示了如何将DOM元素转化为BeanDefinition，包括创建AbstractBeanDefinition对象、设置属性、处理构造器参数以及property节点的解析。此外，还提供了配置文件示例和解析过程，特别是对于集合类型的配置处理。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

参考博客：https://blog.youkuaiyun.com/sunchen2012/article/details/82415656

    //解析Bean定义资源Document对象的普通元素
	protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {

		//将Element元素--->BeanDefinition的过程在此
		//对Document对象中<Bean>元素的解析由BeanDefinitionParserDelegate实现
		BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);  //代码1

		if (bdHolder != null) {
			//修饰BeanDefinition
			bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
			try {
			
				//主线
				//向Spring IOC容器注册解析得到的Bean定义，这是Bean定义向IOC容器注册的入口
				BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
			}
			catch (BeanDefinitionStoreException ex) {
				getReaderContext().error("Failed to register bean definition with name '" +
						bdHolder.getBeanName() + "'", ele, ex);
			}
			
			//在完成向Spring IOC容器注册解析得到的Bean定义之后，发送注册事件
			getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
		}
	}

代码1为解析DOM元素为BeanDefinition，具体操作如下。

由BeanDefinitionParserDelegate提供parseBeanDefinitionElement方法的实现：

    public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
		return parseBeanDefinitionElement(ele, null);
	}
	
	public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
	    //获取id的值
		String id = ele.getAttribute(ID_ATTRIBUTE);
		//获取name的值，作为别名的
		String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

		List<String> aliases = new ArrayList<>();
		if (StringUtils.hasLength(nameAttr)) {
		    //假如name字段有值，则进行解析操作，并添加到别名集合aliases中
		    //name的值可以用“,” “;” ",;" 分割，这里会解析为数组，当成多个别名使用
			String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
			aliases.addAll(Arrays.asList(nameArr));
		}

		//id作为bean的名称
		String beanName = id;
		if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
			//假如id为空，且别名不为空，则取首个别名作为beanName
			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) {
			//判断在当前<beans>中 是否有相同的名称
			checkNameUniqueness(beanName, aliases, ele);
		}
		
		//调用重载方法 进行解析
		//主线
		AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean); 
		if (beanDefinition != null) {
			//假如未声明别名和id的bean，则生成唯一的名称作为beanName
			if (!StringUtils.hasText(beanName)) {
				try {
					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)) {
							//假如类名称未使用，则将类名作为当前bean的别名
							aliases.add(beanClassName);
						}
					}
					
				}
				catch (Exception ex) {
					error(ex.getMessage(), ele);
					return null;
				}
			}
			String[] aliasesArray = StringUtils.toStringArray(aliases);
			//将BeanDefinition封装至BeanDefinitionHolder中，并返回
			return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
		}

		return null;
	}

继续到重载方法，看DOM元素解析过程：

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

		//将当前bean解析入栈，记录解析<bean>的过程，parseState可以通过toString来打印调用栈链
		//下面解析property的时候，也同样记录了
		this.parseState.push(new BeanEntry(beanName));

		String className = null;
		if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
			className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
		}
		String parent = null;
		if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
			parent = ele.getAttribute(PARENT_ATTRIBUTE);
		}

		try {
			//根据类名和父类名创建BeanDefinition
			AbstractBeanDefinition bd = createBeanDefinition(className, parent);   //代码1

			//解析DOM中的属性，并存入到AbstractBeanDefinition对象中
			parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);   //代码2
			//设置描述
			bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));

			//对<Bean>元素的meta(元信息)属性解析
			parseMetaElements(ele, bd);
			//对<Bean>元素的lookup-method属性解析
			parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
			//对<Bean>元素的replaced-method属性解析
			parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

			//解析<Bean>元素的构造方法设置
			parseConstructorArgElements(ele, bd); //代码3
			//解析<Bean>元素的<property>设置
			parsePropertyElements(ele, bd);   //代码4
			//解析<Bean>元素的qualifier属性
			parseQualifierElements(ele, bd);  

			//为当前解析的Bean设置所需的资源和依赖对象
			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;
	}

代码1，创建了AbstractBeanDefinition对象，并设置对应的类信息。以下代码显示如何创建：

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

		return BeanDefinitionReaderUtils.createBeanDefinition(
				parentName, className, this.readerContext.getBeanClassLoader());
	}

接下来看BeanDefinitionReaderUtils的createBeanDefinition方法：

	public static AbstractBeanDefinition createBeanDefinition(
			@Nullable String parentName, @Nullable String className, @Nullable ClassLoader classLoader) throws ClassNotFoundException {

		GenericBeanDefinition bd = new GenericBeanDefinition();
		bd.setParentName(parentName);
		if (className != null) {
			//设置bean的class值
			if (classLoader != null) {
				bd.setBeanClass(ClassUtils.forName(className, classLoader));
			}
			else {
				bd.setBeanClassName(className);
			}
		}
		return bd;
	}

由上述代码发现，实际上创建的AbstractBeanDefinition 的实现为GenericBeanDefinition对象。

代码2，解析<bean>中的属性值如scope、abstract、lazy-init、autowire等等的属性。
配置文件示例：
在这里插入图片描述

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

		//1.x版本的singleton属性已更新到scope中，设置了该属性将报错
		if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {
			error("Old 1.x 'singleton' attribute in use - upgrade to 'scope' declaration", ele);
		}

		//解析scope的值 singleton 或者 prototype
		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.
			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 (DEFAULT_VALUE.equals(lazyInit)) {
			lazyInit = this.defaults.getLazyInit();
		}
		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 ("".equals(autowireCandidate) || DEFAULT_VALUE.equals(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属性
		if (ele.hasAttribute(FACTORY_BEAN_ATTRIBUTE)) {
			bd.setFactoryBeanName(ele.getAttribute(FACTORY_BEAN_ATTRIBUTE));
		}

		return bd;
	}

代码3，解析<bean>元素的constructor-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);
			//假如节点为constructor-arg节点，则执行构造器元素的解析
			if (isCandidateElement(node) && nodeNameEquals(node, CONSTRUCTOR_ARG_ELEMENT)) {
				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);
		//获取name属性值
		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 {
						//记录<constructor-arg>节点的解析，入栈
						this.parseState.push(new ConstructorArgumentEntry(index));
						//将构造器依赖的值解析出来
						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 {
				//记录<constructor-arg>节点的解析，入栈
				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();
			}
		}
	}

代码4，开始解析<property>元素，有点复杂，做好心理准备：

Bean4.java：
在这里插入图片描述

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);
			//假如是property节点，则开始解析
			if (isCandidateElement(node) && nodeNameEquals(node, PROPERTY_ELEMENT)) {
				parsePropertyElement((Element) node, bd);
			}
		}
	}

解析property节点开始：

public void parsePropertyElement(Element ele, BeanDefinition bd) {
		//获取<property>元素名称
		String propertyName = ele.getAttribute(NAME_ATTRIBUTE);
		if (!StringUtils.hasLength(propertyName)) {
			error("Tag 'property' must have a 'name' attribute", ele);
			return;
		}
		//解析<property>的记录，入栈
		this.parseState.push(new PropertyEntry(propertyName));
		try {
			//如果同个bean中有名称相同property，则直接返回
			if (bd.getPropertyValues().contains(propertyName)) {
				error("Multiple 'property' definitions for property '" + propertyName + "'", ele);
				return;
			}
			//获取property的值
			Object val = parsePropertyValue(ele, bd, propertyName);  //代码1
			//根据property的名称和值创建property实例
			PropertyValue pv = new PropertyValue(propertyName, val);
			//解析元信息元素
			parseMetaElements(ele, pv);
			//设置资源
			pv.setSource(extractSource(ele));
			//向BeanDefinition中添加property值，其维护了一个List集合来保存property的值
			bd.getPropertyValues().addPropertyValue(pv);
		}
		finally {
			//出栈
			this.parseState.pop();
		}
	}

代码1位获取property的值，首先，从上图的property配置文件示例可以看出，property的属性值可以为ref、value两种，而子节点可以为ref、value、list、map等，下面代码将呈现如何解析上述属性或者节点。

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

		//要求<property>节点只能有一个子节点，可以是<ref>、<value>、<list>等等
		NodeList nl = ele.getChildNodes();
		Element subElement = null;
		for (int i = 0; i < nl.getLength(); i++) {
			Node node = nl.item(i);
			if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT) &&
					!nodeNameEquals(node, META_ELEMENT)) {
				//假如存在一个以上节点，则会多次循环，第二次循环subElement的值将不为空，则报错。
				if (subElement != null) {
					error(elementName + " must not contain more than one sub-element", ele);
				}
				else {
					//首次循环，subElement为空，为其赋值，假如再进一次循环，将会走上面的分支
					subElement = (Element) node;
				}
			}
		}

		//获取ref属性
		boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE);
		//获取value属性
		boolean hasValueAttribute = ele.hasAttribute(VALUE_ATTRIBUTE);
		//假如（同时有ref、value属性）或者（有子节点并同时存在ref或value属性）则报错
		//意思还是跟上述的要求一样，要求<property>节点只能有一个子节点
		if ((hasRefAttribute && hasValueAttribute) ||
				((hasRefAttribute || hasValueAttribute) && subElement != null)) {
			error(elementName +
					" is only allowed to contain either 'ref' attribute OR 'value' attribute OR sub-element", ele);
		}

		//经过上述验证后，到达此处，已经确保<property>节点只有一个，其实分为三种情况：
		//1、ref属性<property name="age" value="2">
		//2、value属性<property name="student" ref="student1">
		//3、子节点<property name="list"><list><value>2</value></list></property>

		if (hasRefAttribute) {
			//假如有ref属性，则创建并返回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属性，则创建并返回value的值
			TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE));
			valueHolder.setSource(extractSource(ele));
			return valueHolder;
		}
		else if (subElement != null) {
			//假如为子节点的情况，则返回解析的子节点
			return parsePropertySubElement(subElement, bd);  //代码1
		}
		else {
			// Neither child element nor "ref" or "value" attribute found.
			error(elementName + " must specify a ref or value", ele);
			return null;
		}
	}

上述代码讲述了对于<propperty>标签的解析过程，对于<propperty>的值，分别有三种情况，分别是ref属性、value属性、子节点，其中前面两种比较简单，下面重点讲述代码1，解析子节点的过程：

public Object parsePropertySubElement(Element ele, @Nullable BeanDefinition bd) {
		return parsePropertySubElement(ele, bd, null);
	}

调用重载方法，默认值传入空，下面代码有点长，因为加了挺多注释，但是比较重要：

public Object parsePropertySubElement(Element ele, @Nullable BeanDefinition bd, @Nullable String defaultValueType) {

		//假如<property>子元素非默认命名空间，则使用用户自定义规则解析
		if (!isDefaultNamespace(ele)) {
			return parseNestedCustomElement(ele, bd);
		}
		//假如<property>子元素为<bean>元素，则递归调用解析BeanDefinition方法
		// 下面为配置文件示例：
		//<property name="bean1">
		//   <bean class="com.example.demo.test.bean.Bean1"/>
		//</property>
		else if (nodeNameEquals(ele, BEAN_ELEMENT)) {
			BeanDefinitionHolder nestedBd = parseBeanDefinitionElement(ele, bd);
			if (nestedBd != null) {
				nestedBd = decorateBeanDefinitionIfRequired(ele, nestedBd, bd);
			}
			return nestedBd;
		}
		//假如<property>子元素为<ref>元素
		//配置文件示例：
		//<property name="bean3">
        //   <ref bean="bean3"/>
        //</property>
		else if (nodeNameEquals(ele, REF_ELEMENT)) {
			//获取bean属性的值，为ref的引用目标名称
			String refName = ele.getAttribute(BEAN_REF_ATTRIBUTE);
			boolean toParent = false;
			if (!StringUtils.hasLength(refName)) {
				//假如没有指定bean的值，则解析parent的值作为ref的引用目标的名称
				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;
			}
			//创建并返回bean引用
			RuntimeBeanReference ref = new RuntimeBeanReference(refName, toParent);
			ref.setSource(extractSource(ele));
			return ref;
		}
		//假如<property>子元素为<idref>元素
		//<property name="bean3">
        //    <idref bean="bean3"/>
        //</property>
		//则解析其bean，并创建返回bean引用
		else if (nodeNameEquals(ele, IDREF_ELEMENT)) {
			return parseIdRefElement(ele);
		}
		//假如<property>子元素为<value>元素
		//<property name="name">
        //    <value>tony</value>
        //</property>
		else if (nodeNameEquals(ele, VALUE_ELEMENT)) {
			return parseValueElement(ele, defaultValueType);
		}
		//假如<property>子元素为<null>元素
		//<property name="name">
		//    <null>
		//</property>
		else if (nodeNameEquals(ele, NULL_ELEMENT)) {
			//<null>它是一个特殊的空值。为了保留源位置，我们将其封装在TypedStringValue对象中。
			TypedStringValue nullHolder = new TypedStringValue(null);
			nullHolder.setSource(extractSource(ele));
			return nullHolder;
		}
		//假如<property>子元素为<array>元素，解析设置数组的值
		//<property name="name">
        //    <array>
        //        <value>tony老师</value>
		//        <value>jack老师</value>
        //    </array>
        //</property>
		else if (nodeNameEquals(ele, ARRAY_ELEMENT)) {
			return parseArrayElement(ele, bd);
		}
		//假如<property>子元素为<list>元素，解析设置list集合的值
		//<property name="list">
        //    <list>
        //        <value>tony老师</value>
        //        <value>jack老师</value>
        //    </list>
        //</property>
		else if (nodeNameEquals(ele, LIST_ELEMENT)) {
			return parseListElement(ele, bd);
		}
		//假如<property>子元素为<set>元素，解析设置set集合的值
		//<property name="set">
		//   <set>
        //        <value>tony老师</value>
        //        <value>jack老师</value>
        //    </set>
        //</property>
		else if (nodeNameEquals(ele, SET_ELEMENT)) {
			return parseSetElement(ele, bd);
		}
		//假如<property>子元素为<map>元素，解析设置map集合的值
		//<property name="map">
        //    <map>
        //        <entry key="str">
        //            <value>string</value>
        //        </entry>
        //        <entry key="reference">
        //            <ref bean="bean1"/>
        //        </entry>
        //    </map>
        //</property>
		else if (nodeNameEquals(ele, MAP_ELEMENT)) {
			return parseMapElement(ele, bd);
		}
		//假如<property>子元素为<props>元素，解析设置Properties对象的值
		//<property name="properties">
        //    <props>
        //        <prop key="aaa">aaa</prop>
        //    </props>
        //</property>
		else if (nodeNameEquals(ele, PROPS_ELEMENT)) {
			return parsePropsElement(ele);
		}
		else {
			error("Unknown property sub-element: [" + ele.getNodeName() + "]", ele);
			return null;
		}
	}

上述代码事实上，完成了<property>的子元素<bean>、<ref>、<idref>、<value>、<null>、<array>、<list>、<set>、<map>、<props>等的解析。具体的解析过程不再展开，至此结束。

下面插入对于集合类型一些配置示例：

<bean id="bean4" class="com.example.demo.test.bean.Bean4">
        <!--<property name="aaa" value="1"/>-->
        <!--<property name="bean" ref="bean3"/>-->
        <property name="list">
            <list>
                <value>tony老师</value>
                <value>jack老师</value>
            </list>
        </property>
        <property name="aaa">
            <null/>
        </property>
        <property name="name">
            <array>
                <value>tony</value>
            </array>
        </property>
        <property name="properties">
            <props>
                <prop key="aaa">aaa</prop>
            </props>
        </property>

        <property name="set">
            <set>
                <value>tony老师</value>
                <value>jack老师</value>
            </set>
        </property>

        <property name="map">
            <map>
                <entry key="str">
                    <value>string</value>
                </entry>
                <entry key="reference">
                    <ref bean="bean1"/>
                </entry>
            </map>
        </property>
    </bean>