Spring源码阅读之IoC容器初始化2 -- BeanDefinition载入与解析

注1：Spring源码基于Spring3.1版本

注2：参考《Spring技术内幕》第二版

在上一篇博客中从源码分析了Resource的定位，当Resource定位完成后紧接着就是BeanDefinition的载入与解析，但由于过程复杂导致内容很多，因此没有放在一块，这里去读一下Spring源码中的BeanDefinition载入与解析部分。

BeanDefinition载入过程其实就是把定义的BeanDefinition在IoC容器中转化为一个Spring内部表示的数据结构的过程。IoC容器对Bean的管理和依赖注入的实现，都是通过对其持有的BeanDefinition进行各种相关的操作来完成的。这些BeanDefinition数据在IoC容器中通过一个HashMap来维护。

1、容器启动入口 -- refresh方法

在开始分析之前，先回到IoC容器的初始化入口refresh方法，这个方法是在FileSystemXmlApplicationContext的构造函数中被调用的，它的调用标志着容器初始化的开始。refresh定义在AbstractApplicationContext类中，它详细描述了整个ApplicationContext的初始化过程，比如BeanFactory的更新、MessageSource和PostProcessor的注册等。这里看起来像是对ApplicationContext进行初始化的模版或执行提纲，这个执行过程为Bean的生命周期管理提供了条件。

public void refresh() throws BeansException, IllegalStateException {synchronized (this.startupShutdownMonitor) {// 准备刷新容器, 获取容器的当时时间, 同时给容器设置同步标识prepareRefresh();// 启动子类的refreshBeanFactory方法.ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();// 为BeanFactory配置容器特性，例如类加载器、事件处理器等.prepareBeanFactory(beanFactory);try {// 设置BeanFactory的后置处理.postProcessBeanFactory(beanFactory);// 调用BeanFactory的后处理器, 这些后处理器是在Bean定义中向容器注册的.invokeBeanFactoryPostProcessors(beanFactory);// 注册Bean的后处理器, 在Bean创建过程中调用.registerBeanPostProcessors(beanFactory);// 初始化上下文中的消息源.initMessageSource();// 初始化上下文中的事件机制.initApplicationEventMulticaster();// 初始化其它特殊的Bean.onRefresh();// 检查并向容器注册监听器Bean.registerListeners();// 实例化所有剩余的(non-lazy-init) 单例Bean.finishBeanFactoryInitialization(beanFactory);// 发布容器事件, 结束refresh过程.finishRefresh();} catch (BeansException ex) {// 销毁已经创建的单例Bean, 以避免资源占用.destroyBeans();// 取消refresh操作, 重置 'active' 标志.cancelRefresh(ex);throw ex;}}}

2、载入Resource并启动BeanDefinition的解析

根据前面的分析，我们知道，在初始化FileSystemXmlApplicationContext的过程中是通过调用IoC容器的refresh来启动整个BeanDefinition载入过程的，这个初始化是通过定义的XmlBeanDefinitionReader来完成的。同时也可以看出实际使用的IoC容器是DefaultListableBeanFactory，具体的Resource载入在XmlBeanDefinitionReader读入BeanDefinition时实现。在XmlBeanDefinitionReader实现（结合其基类AbstractBeanDefinitionReader的实现）中可以看到，流程最终会调用到AbstractBeanDefinitionReader类的loadBeanDefinitions(Resource resource)方法，但这个方法在AbstractBeanDefinitionReader中并没有实现，它只是一个接口方法，具体的实现在XmlBeanDefinitionReader中。

// 调用入口public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {return loadBeanDefinitions(new EncodedResource(resource));}// 载入XML形式的BeanDefinitionpublic int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();if (currentResources == null) {currentResources = new HashSet<EncodedResource>(4);this.resourcesCurrentlyBeingLoaded.set(currentResources);}if (!currentResources.add(encodedResource)) {throw new BeanDefinitionStoreException("Detected cyclic loading of " + encodedResource + " - check your import definitions!");}try {InputStream inputStream = encodedResource.getResource().getInputStream();try {InputSource inputSource = new InputSource(inputStream);if (encodedResource.getEncoding() != null) {inputSource.setEncoding(encodedResource.getEncoding());}return doLoadBeanDefinitions(inputSource, encodedResource.getResource());} finally {inputStream.close();}} catch (IOException ex) {throw new BeanDefinitionStoreException("IOException parsing XML document from " + encodedResource.getResource(), ex);} finally {currentResources.remove(encodedResource);if (currentResources.isEmpty()) {this.resourcesCurrentlyBeingLoaded.remove();}}}// 从XML中实际载入BeanDefinitionprotected int doLoadBeanDefinitions(InputSource inputSource, Resource resource) throws BeanDefinitionStoreException {try {int validationMode = getValidationModeForResource(resource);// 取得XML文件的Document对象, 这个解析过程由DefaultDocumentLoader完成Document doc = this.documentLoader.loadDocument(inputSource, getEntityResolver(), this.errorHandler, validationMode, isNamespaceAware());// 启动对BeanDefinition解析的详细过程, 解析过程中会使用到Spring的Bean配置规则return registerBeanDefinitions(doc, resource);} catch (BeanDefinitionStoreException ex) {throw ex;} catch (SAXParseException ex) {throw new XmlBeanDefinitionStoreException(resource.getDescription(),"Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);} catch (SAXException ex) {throw new XmlBeanDefinitionStoreException(resource.getDescription(),"XML document from " + resource + " is invalid", ex);} catch (ParserConfigurationException ex) {throw new BeanDefinitionStoreException(resource.getDescription(),"Parser configuration exception parsing XML from " + resource, ex);} catch (IOException ex) {throw new BeanDefinitionStoreException(resource.getDescription(),"IOException parsing XML document from " + resource, ex);} catch (Throwable ex) {throw new BeanDefinitionStoreException(resource.getDescription(),"Unexpected exception parsing XML document from " + resource, ex);}}

上一段代码通过Resource最终得到了org.w3c.dom.Document对象，则DefaultDocumentLoader解析XML文件生成。下面我们看一下Spring是怎样按照Bean配置语义规则进行解析并转化为容器内部数据结构的，这个过程在registerBeanDefinitions(Document doc, Resource resource)方法中完成：

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {// 得到BeanDefinitionDocumentReader来对XML的BeanDefinition进行解析BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();documentReader.setEnvironment(this.getEnvironment());int countBefore = getRegistry().getBeanDefinitionCount();// 具体的解析过程在BeanDefinitionDocumentReader的registerBeanDefinitions方法中完成documentReader.registerBeanDefinitions(doc, createReaderContext(resource));return getRegistry().getBeanDefinitionCount() - countBefore;}protected BeanDefinitionDocumentReader createBeanDefinitionDocumentReader() {return BeanDefinitionDocumentReader.class.cast(BeanUtils.instantiateClass(this.documentReaderClass));}

由以上代码可以看出，在XmlBeanDefinitionReader中的registerBeanDefinitions方法中创建了BeanDefinitionDocumentReader实例，并将具体的BeanDefinition解析委托到其中完成。

3、BeanDefinitionDocumentReader载入并解析org.w3c.dom.Document

BeanDefinition的载入分成两部分，首先通过调用XML的解析器得到Document对象，但这些Document并没有按照Spring的Bean定义规则进行解析。在完成通用的XML解析之后，才是按照Spring Bean定义规则进行解析的地方。这个过程是在BeanDefinitionDocumentReader中实现的，其实就是在默认现实DefaultBeanDefinitionDocumentReader类中完成。

DefaultBeanDefinitionDocumentReader类相关源码：

public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {this.readerContext = readerContext;// 获得Document的根元素Element root = doc.getDocumentElement();doRegisterBeanDefinitions(root);}protected void doRegisterBeanDefinitions(Element root) {String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);if (StringUtils.hasText(profileSpec)) {String[] specifiedProfiles = StringUtils.tokenizeToStringArray(profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);if (!this.environment.acceptsProfiles(specifiedProfiles)) {return;}}// 创建BeanDefinitionParserDelegate, 用于完成真正的解析过程BeanDefinitionParserDelegate parent = this.delegate;this.delegate = createHelper(readerContext, root, parent);// 解析Bean定义之前, 增强解析过程的可扩展性preProcessXml(root);// 从Document的根元素开始进行Bean定义的Document对象parseBeanDefinitions(root, this.delegate);// 解析Bean定义之前, 增强解析过程的可扩展性postProcessXml(root);this.delegate = parent;}protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {if (delegate.isDefaultNamespace(root)) {// 获取Document对象根元素的所有子节点并循环解析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);// 解析Spring的Bean规则默认元素节点} else {delegate.parseCustomElement(ele);// 解析自定义元素节点}}}} else {delegate.parseCustomElement(root);// 解析自定义元素根节点}}private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {// 解析import元素importBeanDefinitionResource(ele);} else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {// 解析alias元素processAliasRegistration(ele);} else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {// 解析bean元素processBeanDefinition(ele, delegate);} else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {// 解析内嵌beans元素, 作为根节点递归解析// recursedoRegisterBeanDefinitions(ele);}}

从上面DefaultBeanDefinitionDocumentReader类相关代码可以看出，Spring首先获取Document的根元素（一般为<beans/>），然后取得根元素所有的子节点并循环解析这些子节点；如果子节点在Spring默认的命名空间内，则按照Spring Bean定义规则来解析，否则按照自定义的节点解析。在按照Spring Bean定义规则进行解析的parseDefaultElement方法中，完成了对<import/>、<alias/>、<bean/>、<beans/>等元素的解析。为了使文章简短一点，在这里只关注Spring对<bean/>元素的解析过程，其它的解析过程不再分析。

这里需要注意的一点是，从parseDefaultElement方法可以看出如果我们将import和alias标签写在XML配置文件的顶部，那么Spring会优先处理它们。

4、DefaultBeanDefinitionDocumentReader解析注册<bean>元素

接下来去关注<bean/>元素的解析：

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {// 具体的解析委托给BeanDefinitionParserDelegate来完成// BeanDefinitionHolder是BeanDefinition的封装类, 封装了BeanDefinition、Bean的名字和别名, 用它来完成向IoC容器注册.BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);if (bdHolder != null) {bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);try {// 向IoC容器注册解析得到的BeanDefinition.BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());} catch (BeanDefinitionStoreException ex) {getReaderContext().error("Failed to register bean definition with name '" + bdHolder.getBeanName() + "'", ele, ex);}// BeanDefinition注册完成后, 发送事件.getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));}}

解析的结果由BeanDefinitionHolder对象持有，该对象除了持有BeanDefinition对象外，还持有其他与BeanDefinition使用相关的信息，比如Bean的名字、别名集合等。同样可以看到这个解析过程是由BeanDefinitionParserDelegate来实现（具体在其processBeanDefinition方法中实现）的，同时这个解析是与Spring Bean配置规则紧密相关的。

5、BeanDefinitionParserDelegate解析<bean>元素

在processBeanDefinition方法中可以看到那些熟悉的BeanDefinition定义的处理，比如id、name、alias等属性元素，这些属性值被读出后都被设置到BeanDefinitionHolder中。除此之外还有一些其它元素配置的解析，如各种Bean的属性配置，通过一个较为复杂的解析过程，这个过程由parseBeanDefinitionElement来完成。解析完成后，为把解析结果放到BeanDefinition对象中并设置BeanDefinition到BeanDefinitionHolder中去。

代码如下：

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {return parseBeanDefinitionElement(ele, null);}public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {// 解析Bean定义资源文件中的<Bean>元素，主要处理<Bean>元素的id，name和aliase属性String id = ele.getAttribute(ID_ATTRIBUTE);String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);List<String> aliases = new ArrayList<String>();if (StringUtils.hasLength(nameAttr)) {String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);aliases.addAll(Arrays.asList(nameArr));}String beanName = id;// 如果<Bean>元素中没有配置id属性时, 将别名中的第一个值赋值给beanNameif (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {beanName = aliases.remove(0);}if (containingBean == null) {checkNameUniqueness(beanName, aliases, ele);}// 对<bean/>元素进行详细解析AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);if (beanDefinition != null) {if (!StringUtils.hasText(beanName)) {try {if (containingBean != null) {beanName = BeanDefinitionReaderUtils.generateBeanName(beanDefinition, this.readerContext.getRegistry(), true);} else {beanName = this.readerContext.generateBeanName(beanDefinition);//为解析的Bean使用别名注册时, 为了向后兼容（Spring1.2/2.0给别名添加类名后缀）String beanClassName = beanDefinition.getBeanClassName();if (beanClassName != null &&beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&!this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {aliases.add(beanClassName);}}} catch (Exception ex) {error(ex.getMessage(), ele);return null;}}String[] aliasesArray = StringUtils.toStringArray(aliases);return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);}return null;}

上面介绍了Bean元素解析的过程，也就是BeanDefinition依据XML中<bean>定义被创建的过程。这个BeanDefinition可以看成<bean>定义的抽象，上面的方法只是基本解析了<bean>元素的一些属性，具体的解析过程被定义在parseBeanDefinitionElement方法中，代码如下：

public AbstractBeanDefinition parseBeanDefinitionElement(Element ele, String beanName,BeanDefinition containingBean) {this.parseState.push(new BeanEntry(beanName));// 这里只读取<Bean>元素中配置的class名字, 然后载入到BeanDefinition中去      // 只是记录配置的class名字, 并不实例化, 对象的实例化在依赖注入时完成String className = null;if (ele.hasAttribute(CLASS_ATTRIBUTE)) {className = ele.getAttribute(CLASS_ATTRIBUTE).trim();}try {String parent = null;if (ele.hasAttribute(PARENT_ATTRIBUTE)) {parent = ele.getAttribute(PARENT_ATTRIBUTE);}// 根据<Bean>元素配置的class名称和parent属性值创建BeanDefinition, 为载入Bean定义信息做准备AbstractBeanDefinition bd = createBeanDefinition(className, parent);// 对当前<Bean>元素中配置的一些属性进行解析, 如singleton、abstract等parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));// 对<Bean>元素的meta(元数据)、lookup-method、replaced-method等子元素进行解析parseMetaElements(ele, bd);parseLookupOverrideSubElements(ele, bd.getMethodOverrides());parseReplacedMethodSubElements(ele, bd.getMethodOverrides());// 解析<Bean>元素的构造方法参数parseConstructorArgElements(ele, bd);// 解析<Bean>元素的<property>设置parsePropertyElements(ele, bd);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>元素并且组装创建的BeanDefinition对象（其实是GenericBeanDefinition实例）的地方，熟悉Spring配置的话很容易就能看出在Spring配置文件中<Bean>元素的中配置的各种属性及子元素就是通过该方法解析并设置到BeanDefinition中去的。

按照源码内容，<bean>元素属性及其子元素的解析顺序为：

1. 解析<bean>元素的属性
2. 解析<description>子元素
3. 解析<meta>子元素
4. 解析<lookup-method/>子元素
5. 解析<replaced-method>子元素
6. 解析<constructor-arg>子元素
7. 解析<property>子元素
8. 解析<qualifier>子元素

6、BeanDefinitionParserDelegate解析<property>元素

上面的解析过程中像<meta>、<qualifier>等子元素都很少使用，最常用的要数<property>子元素了，这里去看一下该元素是如何解析的。

public void parsePropertyElements(Element beanEle, BeanDefinition bd) {// 遍历<bean>所有的子元素NodeList nl = beanEle.getChildNodes();for (int i = 0; i < nl.getLength(); i++) {Node node = nl.item(i);if (isCandidateElement(node) && nodeNameEquals(node, PROPERTY_ELEMENT)) {// 如果是<property>元素, 则对其进行解析parsePropertyElement((Element) node, bd);}}}public void parsePropertyElement(Element ele, BeanDefinition bd) {String propertyName = ele.getAttribute(NAME_ATTRIBUTE);// <property>元素name属性if (!StringUtils.hasLength(propertyName)) {error("Tag 'property' must have a 'name' attribute", ele);return;}this.parseState.push(new PropertyEntry(propertyName));try {// 如果同一个Bean中已经有相同名字的<property>存在, 直接返回// 也就是说, 如果一个Bean中定义了两个名字一样的<property>元素, 只有第一个起作用.if (bd.getPropertyValues().contains(propertyName)) {error("Multiple 'property' definitions for property '" + propertyName + "'", ele);return;}// 解析<property>元素, 返回的对象对应<property>元素的解析结果, 最终封装到PropertyValue中, 并设置到BeanDefinitionHolder中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();}}public Object parsePropertyValue(Element ele, BeanDefinition bd, String propertyName) {String elementName = (propertyName != null) ?"<property> element for property '" + propertyName + "'" :"<constructor-arg> element";// 检查<property>的子元素, 只能是ref, value, list等(description, meta除外)其中的一个.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)) {if (subElement != null) {error(elementName + " must not contain more than one sub-element", ele);} else {subElement = (Element) node;}}}// 判断property元素是否含有ref和value属性, 不允许既有ref又有value属性.// 同时也不允许ref和value属性其中一个与子元素共存.boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE);boolean hasValueAttribute = ele.hasAttribute(VALUE_ATTRIBUTE);if ((hasRefAttribute && hasValueAttribute) ||((hasRefAttribute || hasValueAttribute) && subElement != null)) {error(elementName + " is only allowed to contain either 'ref' attribute OR 'value' attribute OR sub-element", ele);}// 如果属性是ref属性, 创建一个ref的数据对象RuntimeBeanReference, 封装了ref信息if (hasRefAttribute) {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属性, 创建一个数据对象TypedStringValue, 封装了value信息  TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE));valueHolder.setSource(extractSource(ele));return valueHolder;} else if (subElement != null) { // 如果当前<property>元素还有子元素return parsePropertySubElement(subElement, bd);} else {// propery元素既没有ref或value属性, 也没有子元素, 解析出错返回nullerror(elementName + " must specify a ref or value", ele);return null;}}

遍历<bean>元素的所有<property>元素，针对每一个<property>子元素进行具体解析，最后封装成对应的PropertyValue对象，并将其添加到BeanDefinition对象中。对于每一个<property>子元素，可以含有ref属性或value属性，也可以拥有子元素，但不允许同时拥有ref、value和子元素中的两项。如果拥有ref属性，则返回RuntimeBeanReference对象；如果拥有value属性，则返回封装value信息的TypedStringValue对象；如果拥有子元素，则调用parsePropertySubElement方法对子元素继续进行解析，并返回子元素解析结果；如果ref、value和子元素都不具备，则解析出错，方法返回null。

7、BeanDefinitionParserDelegate解析<property>元素的子元素

在对property子元素解析时，Array、List、Set、Map、Prop等各种元素都会在此出现，生成相应的数据对象，比如ManagedList、ManagedArray、ManagedSet等，这些ManagedXXX类是Spring对具体的BeanDefinition的数据封装。每种具体类型的解析过程都被封装在相应的方法中，比如parseArrayElement、parseListElement、parsePropsElement方法等。

如下面代码所示：

public Object parsePropertySubElement(Element ele, BeanDefinition bd) {return parsePropertySubElement(ele, bd, null);}public Object parsePropertySubElement(Element ele, BeanDefinition bd, String defaultValueType) {if (!isDefaultNamespace(ele)) {// 如果子元素没有使用Spring默认命名空间, 则使用用户自定义的规则解析return parseNestedCustomElement(ele, bd);} else if (nodeNameEquals(ele, BEAN_ELEMENT)) {// 如果子元素是bean元素, 则使用解析<bean>元素的方法解析BeanDefinitionHolder nestedBd = parseBeanDefinitionElement(ele, bd);if (nestedBd != null) {nestedBd = decorateBeanDefinitionIfRequired(ele, nestedBd, bd);}return nestedBd;} else if (nodeNameEquals(ele, REF_ELEMENT)) {// 如果子元素是ref, 有且只能有bean、local和parent 3个属性中的一个String refName = ele.getAttribute(BEAN_REF_ATTRIBUTE);// 引用普通任意的beanboolean toParent = false;if (!StringUtils.hasLength(refName)) {refName = ele.getAttribute(LOCAL_REF_ATTRIBUTE);// 引用同一个XML配置文件中的beanif (!StringUtils.hasLength(refName)) {refName = ele.getAttribute(PARENT_REF_ATTRIBUTE);// 引用父容器中的beantoParent = true;if (!StringUtils.hasLength(refName)) {error("'bean', 'local' or 'parent' is required for <ref> element", ele);return null;}}}// ref元素没有bean、local和parent 3个属性中的一个, 返回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;} else if (nodeNameEquals(ele, IDREF_ELEMENT)) {// 如果子元素是<idref>, 使用解析idref元素的方法解析return parseIdRefElement(ele);} else if (nodeNameEquals(ele, VALUE_ELEMENT)) {// 子元素是<value>return parseValueElement(ele, defaultValueType);} else if (nodeNameEquals(ele, NULL_ELEMENT)) {// 子元素是<null>TypedStringValue nullHolder = new TypedStringValue(null);nullHolder.setSource(extractSource(ele));return nullHolder;} else if (nodeNameEquals(ele, ARRAY_ELEMENT)) {// 子元素是<array>return parseArrayElement(ele, bd);} else if (nodeNameEquals(ele, LIST_ELEMENT)) {// 子元素是<list>return parseListElement(ele, bd);} else if (nodeNameEquals(ele, SET_ELEMENT)) {// 子元素是<set>return parseSetElement(ele, bd);} else if (nodeNameEquals(ele, MAP_ELEMENT)) {// 子元素是<map>return parseMapElement(ele, bd);} else if (nodeNameEquals(ele, PROPS_ELEMENT)) {// 子元素是<props>return parsePropsElement(ele);} else {// 以上都不是, 说明配置错误, 返回null.error("Unknown property sub-element: [" + ele.getNodeName() + "]", ele);return null;}}

虽然上面代码中对property元素子元素的解析过程很复杂，但分支明确、清晰明了，想去了解某一种类型的配置是怎样被解析的，可以到相应的解析方法中去查看，这里不再一一将源码贴出，那样的话文章就太长了，在这里只看一下list配置元素是怎样被解析的。代码依然在BeanDefinitionParserDelegate中，parseListElement方法返回的是一个java.util.List对象，这个List是Spring定义的ManagedList，作为封装List这类配置定义的数据封装。

public List parseListElement(Element collectionEle, BeanDefinition bd) {// 获取<list>元素中的value-type属性, 即集合元素的数据类型String defaultElementType = collectionEle.getAttribute(VALUE_TYPE_ATTRIBUTE);NodeList nl = collectionEle.getChildNodes();// <list>元素所有子节点ManagedList<Object> target = new ManagedList<Object>(nl.getLength());target.setSource(extractSource(collectionEle));target.setElementTypeName(defaultElementType);target.setMergeEnabled(parseMergeAttribute(collectionEle));// 具体解析List元素中的值parseCollectionElements(nl, target, bd, defaultElementType);return target;}protected void parseCollectionElements(NodeList elementNodes, Collection<Object> target, BeanDefinition bd, String defaultElementType) {// 遍历集合所有子节点for (int i = 0; i < elementNodes.getLength(); i++) {Node node = elementNodes.item(i);if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT)) {// 如果子节点是Element且不是<description>节点, 则添加进ManagedList.// 同时触发对下层子元素的解析, 递归调用.target.add(parsePropertySubElement((Element) node, bd, defaultElementType));}}}

经过上面分析的层层解析，XML文件中定义的BeanDefinition就被载入到IoC容器中，并在容器中建立了数据映射。这时容器大致完成了管理Bean对象的数据准备工作，但最重要的依赖注入还没有发生，现在IoC容器BeanDefinition中存在的还只是一些静态的配置信息。要完全发挥容器的作用，还需要完成BeanDefinition向容器的注册。