【Spring源码】IOC容器实现(3)--BeanDefinition的载入和解析

水深无声 2022-05-20 05:30 217阅读 0赞

# 前言 #

Github：[https://github.com/yihonglei/thinking-in-spring][https_github.com_yihonglei_thinking-in-spring]

# BeanDefinition的载入和解析概述 #

上文分析了BeanDefiniton的Resource定位过程：

[Spring源码--IOC容器实现(2)--BeanDefinition的Resource定位][Spring_--IOC_2_--BeanDefinition_Resource]

这篇文章分析下BeanDefinition信息的载入过程。

载入过程就是把Resource转化为BeanDefinition作为一个Spring IOC容器内部表示的数据结构的过程。

IOC容器对Bean的管理和依赖注入功能的实现，就是通过对其持有的BeanDefinition进行各种相关操作来完成的。

这些BeanDefinition数据在IOC容器中通过一个HashMap来保护和维护。在上文中，我们从refresh()入口开始，

一直追溯到AbstractBeanDefinitionReader.loadBeanDefinitions()，找到BeanDefinition需要的Resource资源文件。

**AbstractBeanDefinitionReader.loadBeanDefinitions()方法源码：**

public int loadBeanDefinitions(String location, Set<Resource> actualResources) throws BeanDefinitionStoreException {
    	// 这里得到当前定义的ResourceLoader,默认的使用DefaultResourceLoader
    	ResourceLoader resourceLoader = getResourceLoader();
    	if (resourceLoader == null) {
    		throw new BeanDefinitionStoreException(
    				"Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");
    	}
    	/**
    	  * 这里对Resource的路径模式进行解析，得到需要的Resource集合，
    	  * 这些Resource集合指向了我们定义好的BeanDefinition的信息，可以是多个文件。
    	  */
    	if (resourceLoader instanceof ResourcePatternResolver) {
    		// Resource pattern matching available.
    		try {
    			// 调用DefaultResourceLoader的getResources完成具体的Resource定位
    			Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
    			int loadCount = loadBeanDefinitions(resources);
    			if (actualResources != null) {
    				for (Resource resource : resources) {
    					actualResources.add(resource);
    				}
    			}
    			if (logger.isDebugEnabled()) {
    				logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]");
    			}
    			return loadCount;
    		}
    		catch (IOException ex) {
    			throw new BeanDefinitionStoreException(
    					"Could not resolve bean definition resource pattern [" + location + "]", ex);
    		}
    	}
    	else {
    		// Can only load single resources by absolute URL.
    		// 通过ResourceLoader来完成位置定位
    		Resource resource = resourceLoader.getResource(location);
    		int loadCount = loadBeanDefinitions(resource);
    		if (actualResources != null) {
    			actualResources.add(resource);
    		}
    		if (logger.isDebugEnabled()) {
    			logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");
    		}
    		return loadCount;
    	}
    }

资源文件Resource有了，看下是如何将Resource文件载入到BeanDefinition中的？

# 一 将xml文件转换成Document对象 #

Resource载入的具体实现在**AbstractBeanDefinitionReader.loadBeanDefinitions()**，源码：

@Override
    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;
    }

这里调用loadBeanDefinitions(Resource... resources)方法，但是这个方法AbstractBeanDefinitionReader中

没有具体实现。具体实现在BeanDefinitionReader的子类XmlBeanDefinitionReader中实现。

**XmlBeanDefinitionReader.loadBeanDefinitions()源码：**

**loadBeanDefinitions--》调用的入口**

@Override
    public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
    	return loadBeanDefinitions(new EncodedResource(resource));
    }

**loadBeanDefinitions--》载入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!");
    	}
    	try {
    		// 这里得到XML文件，新建IO文件输入流，准备从文件中读取内容
    		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();
    		}
    	}
    }

**doLoadBeanDefinitions--》具体读取过程地方：**

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
    			throws BeanDefinitionStoreException {
    	try {
    		// 将XML文件转换为DOM对象，解析过程由documentLoader实现
    		Document doc = doLoadDocument(inputSource, resource);
    		// 这里是启动对Bean定义解析的详细过程，该解析过程会用到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);
    	}
    }

到这里完成了XML转化为Document对象，主要经历两个过程：**资源文件转化为IO和XML转换为Document对象。**

# 二 按照Spring的Bean规则对Document对象进行解析 #

在上面分析中，通过调用XML解析器将Bean定义资源文件转换得到Document对象，

但是这些Document对象并没有按照Spring的Bean规则进行解析。

需要按照Spring的Bean规则对Document对象进行解析。

如何对Document文件进行解析？

**XmlBeanDefinitionReader.registerBeanDefinitions()源码：**

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
    	// 这里得到BeanDefinitionDocumentReader来对XML的BeanDefinition进行解析
    	BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
    	// 获得容器中注册的Bean数量
    	int countBefore = getRegistry().getBeanDefinitionCount();
    	// 具体的解析过程在registerBeanDefinitions中完成
    	documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
    	// 统计解析的Bean数量
    	return getRegistry().getBeanDefinitionCount() - countBefore;
    }

按照Spring的Bean规则对Document对象解析的过程是在接口BeanDefinitionDocumentReader

的实现类DefaultBeanDefinitionDocumentReader中实现的。

**DefaultBeanDefinitionDocumentReader.registerBeanDefinitions()源码：**

@Override
    public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
    	this.readerContext = readerContext;
    	logger.debug("Loading bean definitions");
    	// 获取根元素
    	Element root = doc.getDocumentElement();
    	// 具体载入过程
    	doRegisterBeanDefinitions(root);
    }

**DefaultBeanDefinitionDocumentReader.doRegisterBeanDefinitions()源码：**

protected void doRegisterBeanDefinitions(Element root) {
    	// Any nested <beans> elements will cause recursion in this method. In
    	// order to propagate and preserve <beans> default-* attributes correctly,
    	// keep track of the current (parent) delegate, which may be null. Create
    	// the new (child) delegate with a reference to the parent for fallback purposes,
    	// then ultimately reset this.delegate back to its original (parent) reference.
    	// this behavior emulates a stack of delegates without actually necessitating one.
    	BeanDefinitionParserDelegate parent = this.delegate;
    	this.delegate = createDelegate(getReaderContext(), root, parent);
    
    	if (this.delegate.isDefaultNamespace(root)) {
    		String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
    		if (StringUtils.hasText(profileSpec)) {
    			String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
    					profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
    			if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
    				if (logger.isInfoEnabled()) {
    					logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec +
    							"] not matching: " + getReaderContext().getResource());
    				}
    				return;
    			}
    		}
    	}
    
    	preProcessXml(root);
    	//从Document的根元素开始进行Bean定义的Document对象
    	parseBeanDefinitions(root, this.delegate);
    	postProcessXml(root);
    
    	this.delegate = parent;
    }

根据Element载入BeanDefinition。

**DefaultBeanDefinitionDocumentReader.parseBeanDefinitions()源码：**

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
        // 如果使用了Spring默认的XML命名空间
    	if (delegate.isDefaultNamespace(root)) {
    		// 遍历根元素的所有子节点
    		NodeList nl = root.getChildNodes();
    		for (int i = 0; i < nl.getLength(); i++) {
    			Node node = nl.item(i);
    			// 如果该节点是XML元素节点
    			if (node instanceof Element) {
    				Element ele = (Element) node;
    				// 如果该节点使用的是Spring默认的XML命名空间
    				if (delegate.isDefaultNamespace(ele)) {
    					// 使用Spring的Bean规则解析元素节点
    					parseDefaultElement(ele, delegate);
    				}
    				else {
    					// 没有使用Spring默认的XML命名空间，则使用用户自定义的解析规则解析元素节点
    					delegate.parseCustomElement(ele);
    				}
    			}
    		}
    	}
    	else {
    		// Document的根节点没有使用Spring默认的命名空间，则使用用户自定义的解析规则解析Document根节点
    		delegate.parseCustomElement(root);
    	}
    }

该方法作用，使用Spring的Bean规则从Document的根元素开始进行Bean定义的Document对象。

这里主要是看节点元素是否是Spring的规范，因为它允许我们自定义解析规范，

那么正常我们是利用Spring的规则，所以我们来看parseDefaultElement(ele, delegate)方法。

**DefaultBeanDefinitionDocumentReader.parseDefaultElement()源码：**

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
    	// 如果元素节点是<Import>导入元素，进行导入解析
    	if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
    		importBeanDefinitionResource(ele);
    	}
    	// 如果元素节点是<Alias>别名元素，进行别名解析
    	else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
    		processAliasRegistration(ele);
    	}
    	// 如果普通的<Bean>元素，按照Spring的Bean规则解析元素
    	else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
    		processBeanDefinition(ele, delegate);
    	}
    	// 如果普通的<Beans>元素，调用doRegisterBeanDefinitions()递归处理
    	else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
    		// recurse
    		doRegisterBeanDefinitions(ele);
    	}
    }

根据Bean的属性，调用不同的规则解析元素，这里讨论普通Bean元素的解析规则，

调用processBeanDefinition规则进行Bean处理。

**DefaultBeanDefinitionDocumentReader.processBeanDefinition()源码：**

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
    	/**
    	  * BeanDefinitionHolder是对BeanDefinition对象的封装，封装了BeanDefinition、Bean的名字和别名。
     	  * 用来完成想IOC容器注册。得到BeanDefinitionHolder就意味着是通过BeanDefinitionParserDelegate
    	  * 对XML元素的信息按照Spring的Bean规则进行解析得到的。
    	  *
    	  */
    	BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
    	if (bdHolder != null) {
    		bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
    		try {
    			// Register the final decorated instance.
    			// 这里是向IOC容器注册解析得到的BeanDefinition的地方
    			BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
    		}
    		catch (BeanDefinitionStoreException ex) {
    			getReaderContext().error("Failed to register bean definition with name '" +
    					bdHolder.getBeanName() + "'", ele, ex);
    		}
    		// Send registration event.
    		// 在BeanDefinition向IOC容器注册以后，发送消息
    		getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
    	}
    }

# 三 Bean资源的解析 #

具体解析过程委托给BeanDefinitionParserDelegate的parseBeanDefinitionElement来完成。

**BeanDefinitionParserDelegate.parseBeanDefinitionElement()源码：**

**调用解析方法入口：**

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
    	return parseBeanDefinitionElement(ele, null);
    }

**具体对Bean元素定义的处理过程：**

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
    	// 在这里取得<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;
    	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>定义被创建的过程。

这个BeanDefinition可以看成是对<bean>定义的抽象。这个数据对象中封装的数据大多都是与<bean>

定义相关的，也有很多就是我们在定义Bean时看到的那些Spring标记，比如常见的init-method、destory-method、

factory-method等等，这个BeanDefinition数据类型非常重要，它封装了很多基本数据，这些基本数据都是IOC容器

需要的。有了这些基本数据，IOC容器才能对Bean配置进行处理，才能实现相应的容器特性。

**BeanDefinition定义元素的处理：**

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>的构造函数设置
    		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;
    }

上面是具体生成BeanDefinition的地方。在这里举一个对property进行解析的例子来完成对整个

BeanDefinition载入过程的分析，还是在类BeanDefinitionParserDelegate的代码中，一层一层

的对BeanDefinition中的定义进行解析，比如从属性元素结合到具体的每一个属性元素，然后才道

具体值的处理。根据解析结果，对这些属性值的处理会被封装成PropertyValue对象并设置到

BeanDefinition对象中去。

**BeanDefinition中property元素集合的处理：**

**BeanDefinitionParserDelegate.parsePropertyElements()方法入口**

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);
    		// 判断是property元素后对该property元素进行解析
    		if (isCandidateElement(node) && nodeNameEquals(node, PROPERTY_ELEMENT)) {
    			parsePropertyElement((Element) node, bd);
    		}
    	}
    }

**BeanDefinitionParserDelegate.parsePropertyElement()方法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;
       }
       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值的地方，返回的对象对应Bean定义的property属性设置的解析结果，
          * 这个解析结果会封装到PropertyValue对象中，然后设置。
          */
          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();
       }
    }

**BeanDefinitionParserDelegate.parsePropertyValue()方法解析property的value值：**

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,不允许同时出现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的数据对象TypedStringValue，这个对象封装了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等各种元素都会在这里解析，生成对应的数据对象，

比如ManagedList、ManagedArray、ManagedSet等等。这些ManagedXX类是Spring对具体的BeanDefinition的

数据封装。具体的解析可以从parsePropertySubElement()关于property子元素的解析深入追踪，可以看到

parseArrayElement、parseListElement、parseSetElement、parseMapElement、parsePropsElement等方法处理。

**BeanDefinitionParserDelegate.parsePropertySubElement()方法子元素解析源码：**

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

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.parseListElement()方法List属性解析源码：**

public List<Object> 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;
    }

**BeanDefinitionParserDelegate.parseCollectionElements()方法List属性具体的解析源码：**

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中国，target是一个ManagedList，同时触发对下一层子元素的解析过程，
             // 这是一个递归的调用，逐层地解析
             target.add(parsePropertySubElement((Element) node, bd, defaultElementType));
          }
       }
    }

经过逐层地解析，我们在XML文件中定义的BeanDefinition就被整个载入到了IOC容器中，

并在容器中建立了数据映射。在IOC容器中建立了对应的数据结构，或者可以看成是POJO对象

在IOC容器中的抽象，这些数据结构可以以AbstracBeanDefinition为入口，让IOC容器执行索引、

查询和操作。

每一个简单的POJO操作的背后其实都含着一个复杂的抽象过程，经过以上的载入过程，IOC容器

大致完成了管理Bean对象的数据准备工作也即是数据初始化过程。严格来说，这个时候容器还没有起作用，

要完全发挥容器的作用，还需要完成数据向容器的注册，也即[IOC容器注册BeanDefinition][IOC_BeanDefinition]**。**

# 参考文献 #

**1、《Spring技术内幕》**

**2、《Spring实战》**

**3、Spring官网API**

**4、Spring源码**

[https_github.com_yihonglei_thinking-in-spring]: https://github.com/yihonglei/thinking-in-spring
[Spring_--IOC_2_--BeanDefinition_Resource]: https://blog.csdn.net/yhl_jxy/article/details/81019139
[IOC_BeanDefinition]: https://blog.csdn.net/yhl_jxy/article/details/81035291