Spring源码阅读之IoC容器初始化2 -- BeanDefinition载入与解析
注1：Spring源码基于Spring3.1版本注2：参考《Spring技术内幕》第二版在上一篇博客中从源码分析了Resource的定位，当Resource定位完成后紧接着就是BeanDefinition的载入与解析，但由于过程复杂导致内容很多，因此没有放在一块，这里去读一下Spring源码中的BeanDefinition载入与解析部分。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形式的BeanDefinition
public 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中实际载入BeanDefinition
protected 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元素, 作为根节点递归解析
// recurse
doRegisterBeanDefinitions(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属性时, 将别名中的第一个值赋值给beanName
if (!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>元素属性及其子元素的解析顺序为：
- 解析<bean>元素的属性
- 解析<description>子元素
- 解析<meta>子元素
- 解析<lookup-method/>子元素
- 解析<replaced-method>子元素
- 解析<constructor-arg>子元素
- 解析<property>子元素
- 解析<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属性, 也没有子元素, 解析出错返回null
error(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); // 引用普通任意的bean
boolean toParent = false;
if (!StringUtils.hasLength(refName)) {
refName = ele.getAttribute(LOCAL_REF_ATTRIBUTE); // 引用同一个XML配置文件中的bean
if (!StringUtils.hasLength(refName)) {
refName = ele.getAttribute(PARENT_REF_ATTRIBUTE); // 引用父容器中的bean
toParent = 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向容器的注册。
云原生社区为您提供最前沿的新闻资讯和知识内容
更多推荐
0
0- 0
已为社区贡献6条内容
所有评论(0)