Spring技术内幕——Spring Framework的IOC容器实现（3）

接上一篇的时序图。这里调用的loadBeanDefintions实际上是一个抽象方法，那么实际载入过程发生在哪里呢？在loadBeanDefintions中，初始化了读取器XMLBeanDefinitionReader，然后把这个读取器在IOC容器中设置好（过程和编程式使用XMLBeanFactory是类似的），最后是启动读取器来完成BeanDefinition在IOC容器中的载入，代码如下：

/** * Convenient base class for [email protected] org.springframework.context.ApplicationContext} * implementations, drawing configuration from XML documents containing bean definitions * understood by an [email protected] org.springframework.beans.factory.xml.XmlBeanDefinitionReader}. * * <p>Subclasses just have to implement the [email protected] #getConfigResources} and/or * the [email protected] #getConfigLocations} method. Furthermore, they might override * the [email protected] #getResourceByPath} hook to interpret relative paths in an * environment-specific fashion, and/or [email protected] #getResourcePatternResolver} * for extended pattern resolution. * * @author Rod Johnson * @author Juergen Hoeller * @see #getConfigResources * @see #getConfigLocations * @see org.springframework.beans.factory.xml.XmlBeanDefinitionReader */public abstract class AbstractXmlApplicationContext extends AbstractRefreshableConfigApplicationContext {    private boolean validating = true;    /**     * Create a new AbstractXmlApplicationContext with no parent.     */    public AbstractXmlApplicationContext() {    }    /**     * Create a new AbstractXmlApplicationContext with the given parent context.     * @param parent the parent context     */    public AbstractXmlApplicationContext(ApplicationContext parent) {        super(parent);    }    /**     * Set whether to use XML validation. Default is [email protected] true}.     */    public void setValidating(boolean validating) {        this.validating = validating;    }    /**     * Loads the bean definitions via an XmlBeanDefinitionReader.     * @see org.springframework.beans.factory.xml.XmlBeanDefinitionReader     * @see #initBeanDefinitionReader     * @see #loadBeanDefinitions     * 这里是实现loadBeandefinitions的地方     */    @Override    protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {        // Create a new XmlBeanDefinitionReader for the given BeanFactory.        // 创建XMLBeanDefinitionReader，并通过回调设置到BeanFactory中去，创建BeanFactory的过程        // 可以参考上下文对编程式使用IOC容器的相关分析        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);        // Configure the bean definition reader with this context's        // resource loading environment.        // 设置XMLBeanDefinitionReader，为XmlBeanDefinitionReader配置ResourceLoader，        // 因为DefaultResourceLoader是父类，所有this可以直接被使用        beanDefinitionReader.setEnvironment(this.getEnvironment());        beanDefinitionReader.setResourceLoader(this);        beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));        // Allow a subclass to provide custom initialization of the reader,        // then proceed with actually loading the bean definitions.        // 这是启动Bean定义信息载入的过程        initBeanDefinitionReader(beanDefinitionReader);        loadBeanDefinitions(beanDefinitionReader);    }    /**     * Initialize the bean definition reader used for loading the bean     * definitions of this context. Default implementation is empty.     * <p>Can be overridden in subclasses, e.g. for turning off XML validation     * or using a different XmlBeanDefinitionParser implementation.     * @param reader the bean definition reader used by this context     * @see org.springframework.beans.factory.xml.XmlBeanDefinitionReader#setDocumentReaderClass     */    protected void initBeanDefinitionReader(XmlBeanDefinitionReader reader) {        reader.setValidating(this.validating);    }    /**     * Load the bean definitions with the given XmlBeanDefinitionReader.     * <p>The lifecycle of the bean factory is handled by the [email protected] #refreshBeanFactory}     * method; hence this method is just supposed to load and/or register bean definitions.     * @param reader the XmlBeanDefinitionReader to use     * @throws BeansException in case of bean registration errors     * @throws IOException if the required XML document isn't found     * @see #refreshBeanFactory     * @see #getConfigLocations     * @see #getResources     * @see #getResourcePatternResolver     */    protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {        // 以Resource的方式获得配置文件的资源位置        Resource[] configResources = getConfigResources();        if (configResources != null) {            reader.loadBeanDefinitions(configResources);        }        // 以String的形式获得配置文件的位置        String[] configLocations = getConfigLocations();        if (configLocations != null) {            reader.loadBeanDefinitions(configLocations);        }    }    /**     * Return an array of Resource objects, referring to the XML bean definition     * files that this context should be built with.     * <p>The default implementation returns [email protected] null}. Subclasses can override     * this to provide pre-built Resource objects rather than location Strings.     * @return an array of Resource objects, or [email protected] null} if none     * @see #getConfigLocations()     */    protected Resource[] getConfigResources() {        return null;    }}

通过以上对实现原理的分析，我们可以看到在初始化FileSystemXMLApplicationContext的过程中是通过调用IOC容器的refresh来启动整个BeanDefinition的载入过程的，这个初始化时通过定义XMLBeanDefinitionReader来完成的。同时我们也知道实际使用IOC容器是DefaultListableBeanFactory，具体的Resource载入在XMLBeanDefinitionReader读入BeanDefinition时实现。因为Spring可以对应不同形式的BeanDefinition。由于这里使用的是XML方式的定义，所以需要使用XMLBeanDefinitionReader。如果使用了其他的BeanDefinition方式，就需要使用其他种类的BeanDefinitionReader来完成数据的载入工作。在XMLBeanDefinitionReader的实现中可以看到，是在reader.loadBeanDefintions中开始进行BeanDefinition的载入的，而这时XMLBeanDefinitionReader的父类AbstractBeanDefinitionReader已经为BeanDefinition的载入做好了准备，代码如下：

public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {        // 如果Resource为空，则停止BeanDefinition的载入        // 然后启动载入BeanDefinition的过程，这个过程会遍历整个Resource集合所包含的BeanDefinition信息        Assert.notNull(resources, "Resource array must not be null");        int counter = 0;        for (Resource resource : resources) {            counter += loadBeanDefinitions(resource);        }        return counter;    }

这里调用的是loadBeanDefinition(Resource res)方法，但是这个方法在AbstractBeanDefinitionReader类里是没有实现的，他是一个接口方法。具体的实现在XMLBeanDefinitionReader中。在读取器中，需要得到代表Xml文件的Resource，因为这个Resource对象封装了对Xml文件的I/O操作，所以读取器可以在打开I/O流后得到XML的文件对象。有了这个文件对象以后，就可以按照Spring的Bean定义规则来对这个Xml文档进行解析了，这个解析是交给了BeanDefinitionParserDelegate来完成的，具体参见代码如下：
在XmlBeanDefinitionReader extends AbstractBeanDefinitionReader中

  /**     * Load bean definitions from the specified XML file.     * @param resource the resource descriptor for the XML file     * @return the number of bean definitions found     * @throws BeanDefinitionStoreException in case of loading or parsing errors     * 这里是调用的入口     */    public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {        return loadBeanDefinitions(new EncodedResource(resource));    }

/**     * Load bean definitions from the specified XML file.     * @param encodedResource the resource descriptor for the XML file,     * allowing to specify an encoding to use for parsing the file     * @return the number of bean definitions found     * @throws BeanDefinitionStoreException in case of loading or parsing errors     * 这里是载入Xml形式的BeanDefinition的地方     */    public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {        Assert.notNull(encodedResource, "EncodedResource must not be null");        if (logger.isInfoEnabled()) {            logger.info("Loading XML bean definitions from " + encodedResource.getResource());        }        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!");        }        // 这里得到Xml文件，并得到IO的InputSource的准备进行读取        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();            }        }    }

  /**     * Actually load bean definitions from the specified XML file.     * @param inputSource the SAX InputSource to read from     * @param resource the resource descriptor for the XML file     * @return the number of bean definitions found     * @throws BeanDefinitionStoreException in case of loading or parsing errors     * 具体的读取过程可以再doLoadBeanDefinitions方法看到     * 这是从特定的Xml文件中实际载入BeanDefinition的地方     */    protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)            throws BeanDefinitionStoreException {        try {            int validationMode = getValidationModeForResource(resource);            // 这里取得Xml文件的Document对象，这个解析过程是由documentLoader完成的这个            // documentLoader是DefaultDocumentLoader在定义documentLoader的地方创建            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);        }    }

感兴趣的读者可以到DefaultDocument中去看看如何得到Document对象。我们关心的是Spring的BeanDefinition是怎样按照Spring的Bean语义要求进行解析并转化为容器内部数据结构的，这个过程是在registerBeanDefinitions(doc,resource)中完成的。具体的过程由BeanDefinitionDocumentReader来完成，这个RegisterBeanDefinition还对载入的Bean的数量进行了统计，代码如下：

/**     * Register the bean definitions contained in the given DOM document.     * Called by {@code loadBeanDefinitions}.     * <p>Creates a new instance of the parser class and invokes     * {@code registerBeanDefinitions} on it.     * @param doc the DOM document     * @param resource the resource descriptor (for context information)     * @return the number of bean definitions found     * @throws BeanDefinitionStoreException in case of parsing errors     * @see #loadBeanDefinitions     * @see #setDocumentReaderClass     * @see BeanDefinitionDocumentReader#registerBeanDefinitions     */    public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {        // 这里得到BeanDefinitionDocumentReader来对XML的BeanDefinition来解析        BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();        documentReader.setEnvironment(this.getEnvironment());        int countBefore = getRegistry().getBeanDefinitionCount();        // 具体的解析过程是在这个registerBeanDefinitions中完成        documentReader.registerBeanDefinitions(doc, createReaderContext(resource));        return getRegistry().getBeanDefinitionCount() - countBefore;    }

BeanDefinition的载入分成两部分，首先通过调用XML的解析器得到document对象，但这些document对象并没有按照Spring的Bean规则进行解析。在完成通用的XML解析以后才是按照Spring的Bean规则进行解析的地方，这个按照Spring的Bean规则进行解析的过程是在documentReader中实现的。BeanDefinition-Holder的生成是通过对Document文档输的内容进行解析完成的，可以看到这个解析过程是由BeanDefinitionParserDelegate来实现的，同时这个解析是与Spring对BeanDefinition的配置规则紧密关联的。
具体的Spring BeanDefinition的解析是在BeanDefinitionParserDelegate中完成。这个类包含了各种Spring Bean的定义规则。我们最熟悉的对Bean元素的处理是怎样完成的。在这里会看到那些熟悉的BeanDefinition定义的处理，如id,name,aliase等。把这些元素的值从XML文件相应的元素属性读取出来，设置到BeanDefinitionHolder中去，通过一个较为复杂的解析过程，这个由parseBeanDefinitionElement来完成。解析完成以后，会把解析结果放到BeanDefinition对象中并设置BeanDefinitionHolder中去，代码如下：

/**     * Parses the supplied [email protected] &lt;bean&gt;} element. May return [email protected] null}     * if there were errors during parse. Errors are reported to the     * [email protected] org.springframework.beans.factory.parsing.ProblemReporter}.     */    public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {        // 这里取得Bean元素定义的id，name等属性        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;        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);        }        // 这个方法会对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);                        // Register an alias for the plain bean class name, if still possible,                        // if the generator returned the class name plus a suffix.                        // This is expected for Spring 1.2/2.0 backwards compatibility.                        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;    }

上面介绍对Bean元素进行解析的过程，也就是BeanDefinition依据Xml的定义被创建过程。这个数据对象中封装的数据大多都是与bean定义相关的，也有很多就是我们在定义Bean时看到那些Spring标记。例如:init-method,destory-method,factory-method等，这个BeanDefinition数据类型非常重要，他封装了很多基本数据，这些基本数据都是IOC容器需要的。有了这些基本的数据IOC容器才能对Bean配置进行处理，才能实现相应的容器特性。
BeanClass，description、lazyInit都是在配置bean时经常碰到的，都集中在BeanDefinition，是IOC容器非常重要的核心数据结构，对BeanDefinition元素处理在类BeanDefinitionParserDelegate如下代码：

/**     * Parse the bean definition itself, without regard to name or aliases. May return     * [email protected] null} if problems occurred during the parsing of the bean definition.     */    public AbstractBeanDefinition parseBeanDefinitionElement(            Element ele, String beanName, BeanDefinition containingBean) {        this.parseState.push(new BeanEntry(beanName));        // 这里只读取定义的bean中设置的class名字，然后载入到BeanDefinition中去，只是做个记录，并不涉及对象实例化过程        // 对象实例化实际上在依赖注入时完成的        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);            }            // 这里生成需要的BeanDefinition对象，为Bean定义信息的载入做准备            AbstractBeanDefinition bd = createBeanDefinition(className, parent);            // 这里对当前的Bean元素进行属性解析，并设置description信息            parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);            bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));            // 这里是对各种bean元素信息进行解析            parseMetaElements(ele, bd);            parseLookupOverrideSubElements(ele, bd.getMethodOverrides());            parseReplacedMethodSubElements(ele, bd.getMethodOverrides());            // 解析bean的构造函数、property设置            parseConstructorArgElements(ele, bd);            parsePropertyElements(ele, bd);            parseQualifierElements(ele, bd);            bd.setResource(this.readerContext.getResource());            bd.setSource(extractSource(ele));            return bd;        }        // 下面的异常是在配置bean出现问题时经常看到的，原来抛出异常实在createBeanDefinition进行检查的        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;    }

上面时具体生成BeanDefinition的地方。这里我们举一个对property进行解析的例子来完成对整个BeanDefinition载入过程的分析，还是在类BeanDefinitionParserDelegate的代码中，一层一层对BeanDefinition中的定义进行解析，对这些属性值的处理会被封装成PropertyValue对象并设置到BeanDefinition对象中去，代码如下：

    /**     * Parse property sub-elements of the given bean element.     * 这里对指定Bean元素的property子元素集合进行解析     */    public void parsePropertyElements(Element beanEle, BeanDefinition bd) {        NodeList nl = beanEle.getChildNodes();        // 遍历所有元素下定义的property元素        for (int i = 0; i < nl.getLength(); i++) {            Node node = nl.item(i);            if (isCandidateElement(node) && nodeNameEquals(node, PROPERTY_ELEMENT)) {                parsePropertyElement((Element) node, bd);            }        }    }

解析一个property元素

    /**     * Parse a property element.     */    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;        }        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值的地方，这个解析结果会封装到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();        }    }

   /**     * Get the value of a property element. May be a list etc.     * Also used for constructor arguments, "propertyName" being null in this case.     * 这里取得property元素的值，也许是一个list或其他     */    public Object parsePropertyValue(Element ele, BeanDefinition bd, String propertyName) {        String elementName = (propertyName != null) ?                        "<property> element for property '" + propertyName + "'" :                        "<constructor-arg> element";        // Should only have one child element: ref, value, list, etc.        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)) {                // 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;                }            }        }        // 这里判断property属性是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;        }        // 如果是value，创建一个value的数据对象TypeStringValue，封装value信息        else if (hasValueAttribute) {            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.            error(elementName + " must specify a ref or value", ele);            return null;        }    }

这里是对property子元素的解析过程，Array、list、Set、Map、Prop等各种元素都会在这里解析，生成对应的数据对象。下面以Property的元素进行解析为例，代码如下：

/**     * Parse a value, ref or collection sub-element of a property or     * constructor-arg element.     * @param ele subelement of property element; we don't know which yet     * @param defaultValueType the default type (class name) for any     * [email protected] &lt;value&gt;} tag that might be created     */    public Object parsePropertySubElement(Element ele, BeanDefinition bd, 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 the same XML file.                refName = ele.getAttribute(LOCAL_REF_ATTRIBUTE);                if (!StringUtils.hasLength(refName)) {                    // A reference to the id of another bean in a parent context.                    refName = ele.getAttribute(PARENT_REF_ATTRIBUTE);                    toParent = true;                    if (!StringUtils.hasLength(refName)) {                        error("'bean', 'local' 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;        }        else if (nodeNameEquals(ele, IDREF_ELEMENT)) {            return parseIdRefElement(ele);        }        else if (nodeNameEquals(ele, VALUE_ELEMENT)) {            return parseValueElement(ele, defaultValueType);        }        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;        }        else if (nodeNameEquals(ele, ARRAY_ELEMENT)) {            return parseArrayElement(ele, bd);        }        else if (nodeNameEquals(ele, LIST_ELEMENT)) {            return parseListElement(ele, bd);        }        else if (nodeNameEquals(ele, SET_ELEMENT)) {            return parseSetElement(ele, bd);        }        else if (nodeNameEquals(ele, MAP_ELEMENT)) {            return parseMapElement(ele, bd);        }        else if (nodeNameEquals(ele, PROPS_ELEMENT)) {            return parsePropsElement(ele);        }        else {            error("Unknown property sub-element: [" + ele.getNodeName() + "]", ele);            return null;        }    }

下面看看List这样的属性配置怎样被解析，仍然是在BeanDefinitionParserDelegate中，返回的是一个List对象，这个List是Spring定义的ManageList，作为封装List这类配置定义的数据封装，代码如下：

/**     * Parse a list element.     */    public List parseListElement(Element collectionEle, BeanDefinition bd) {        String defaultElementType = collectionEle.getAttribute(VALUE_TYPE_ATTRIBUTE);        NodeList nl = collectionEle.getChildNodes();        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) {        // 遍历多有的元素节点，判断其类型是否为Element        for (int i = 0; i < elementNodes.getLength(); i++) {            Node node = elementNodes.item(i);            if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT)) {                // 加入到target中，是一个ManageList，同时出发对下一层元素的解析，这是一个递归调用                target.add(parsePropertySubElement((Element) node, bd, defaultElementType));            }        }    }

经过这样的逐层解析，我们在XML中定义的BeanDefinition就被整个载入到IOC容器中，并在容器中建立了数据隐射。在IOC容器中建立了对应的数据结构，或者说看成POJO对象在IOC容器中的抽象，这些数据结构可以以AbstractBeanDefinition为入口，让IOC容器执行索引、查询和操作。但是，重要的依赖注入实际上这个时候还没有发生，现在IOC容器BeanDefinition中存在的还只是一些静态的配置信息，严格的说，这个时候容器还没有完全起作用，要完全发挥容器的作用，还需要向数据容器的注册。
未完待续……