Spring5 源码解析 IOC默认标签解析上半部分之解析BeanDefinition

前言

前两篇文章，Spring5源码解析_整体架构分析、IOC容器的基本实现大家应该对Spring的IOC容器有了初步的了解，接下来我们研究Spring标签的解析，Spring标签中由默认标签和自定义标签组成，两者的解析截然不同，本次主要讲解一下默认标签解析的过程

首先我们要知道默认标签的解析过程是在

DefaultBeanDefinitionDocumentReader

的

parseDefaultElement

方法，这个方法中对4种标签(import、alisa、bean和beans)做了不同的解析处理

看源码(

DefaultBeanDefinitionDocumentReader.java

)

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {importBeanDefinitionResource(ele);} else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {processAliasRegistration(ele);} else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {// Bean标签的解析及注册processBeanDefinition(ele, delegate);} else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {// recursedoRegisterBeanDefinitions(ele);}}

Bean标签的解析及注册

在上述parseDefaultElement()方法对4种标签进行了解析，其中bean标签的解析最为复杂也相对比较重要。所以接下来我们先从此标签开始入手。

看源码(

DefaultBeanDefinitionDocumentReader.java

)

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);if (bdHolder != null) {bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);try {// Register the final decorated instance.BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());}catch (BeanDefinitionStoreException ex) {getReaderContext().error("Failed to register bean definition with name \'" +bdHolder.getBeanName() + "\'", ele, ex);}// Send registration event.getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));}}

我们可以先理一下上面函数

processBeanDefinition

的逻辑：

解析BeanDefinition

首先委托BeanDefinitionParserDelegate的parseBeanDefinitionElement方法进行元素的解析，返回BeanDefinitionHolder的实例：bdHolder；经过这一步bdHolder实例已经包含了我们配置文件中的各种属性了，例如class，name，id，alias等。
当返回的bdHolder不为空的情况下若存在默认标签的子节点下再有自定义属性，还需要再次对自定义标签进行解析。
```
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
```
当解析完成后，需要对解析后的bdHolder进行注册，这一步注册委托给了BeanDefinitionReaderUtils的registerBeanDefinition方法；
```
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
```
最后发出响应事件，通知相关的监听器已经加载完这个Bean了。

接下来我们详细的看一下每一步是怎么做的。

1. 解析BeanDefinition

我们接下来具体分析一下上述第一步，元素的解析及信息的提取也就是

BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);

，进入到该函数：

看源码(
```
BeanDefinitionParserDelegate.java
```
)

@Nullablepublic BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {// 解析id属性String id = ele.getAttribute(ID_ATTRIBUTE);// 解析name属性String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);// 分割name属性List<String> aliases = new ArrayList<>();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.isTraceEnabled()) {logger.trace("No XML \'id\' specified - using \'" + beanName +"\' as bean name and " + aliases + " as aliases");}}// 检查name的唯一性if (containingBean == null) {checkNameUniqueness(beanName, aliases, ele);}// 解析 属性 构造 AbstractBeanDefinitionAbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);if (beanDefinition != null) {// 如果beanName不存在，那就根据根据条件构造一个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.isTraceEnabled()) {logger.trace("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);// 封装 BeanDefinitionHolderreturn new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);}return null;}

源码分析

上述方法就是对默认标签的元素解析和信息的提取，对上述方法简单的总结一下：

提取解析元素中的id和name属性
进一步解析其它属性并统一封装到GenericBeanDefinition(GenericBeanDefinition是AbstractBeanDefinition实现类)类型的实例中。
如果检测到bean没有指定beanName，那么使用默认规则为此bean生成beanName、
将获取到的信息封装到BeanDefinitionHolder的实例中

上面的第二步也就是代码：

AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);

对标签中的其它属性进行解析。我们看一下：

看源码(
```
BeanDefinitionParserDelegate.java
```
)

@Nullablepublic AbstractBeanDefinition parseBeanDefinitionElement(Element ele, String beanName, @Nullable BeanDefinition containingBean) {this.parseState.push(new BeanEntry(beanName));String className = null;// 解析class属性if (ele.hasAttribute(CLASS_ATTRIBUTE)) {className = ele.getAttribute(CLASS_ATTRIBUTE).trim();}String parent = null;// 解析parent属性if (ele.hasAttribute(PARENT_ATTRIBUTE)) {parent = ele.getAttribute(PARENT_ATTRIBUTE);}try {// 创建用于承载属性的 AbstractBeanDefinition 类型的 GenericBeanDefinitionAbstractBeanDefinition bd = createBeanDefinition(className, parent);// 硬编码解析Bean的各种属性parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);// 设置 description 属性bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));// 解析 meta 元素parseMetaElements(ele, bd);// 解析 lookup-method属性parseLookupOverrideSubElements(ele, bd.getMethodOverrides());// 解析 replaced-method 属性parseReplacedMethodSubElements(ele, bd.getMethodOverrides());// 解析构造函数的参数parseConstructorArgElements(ele, bd);// 解析properties子元素parsePropertyElements(ele, bd);// 解析qualifier子元素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(也就是上面这个方法)里面的步骤详细追踪一下。

创建用于承载属性的BeanDefinition

说这里的时候我们首先要清楚BeanDefinition是一个接口，在Spring中此接口主要有三种实现方式：

RootBeanDefinition
ChildBeanDefinition
GenericBeanDefinition

以上三种实现类都继承了

AbstractBeanDefinition

，其中BeanDefiniton是配置文件元素标签在容器内部的表现形式。元素标签拥有了class、scope、lazy-init等属性，BeanDefiniton则提供了相应的beanClass、scope、lazyInit属性，BeanDefinition和bean标签中的属性一一对应。其中RootBeanDefinition是最常用的实现类，它对应一般性的元素标签，GenricBeanDefinition是自2.5版本以后新加入的bean文件配置属性定义类，是一站式服务的。

在配置文件中可以定义父和子，父用RootBeanDefinition表示，而自用ChildBeanDefinition表示，而没有父的就是用RootBeanDefiniton表示，AbstractBeanDefinition对两者共同的类信息进行抽象。

Spring通过BeanDefiniton将配置文件中的配置信息转换为容器的内部表示，并将这些BeanDefiniton注册到BeanDefinitionRegistry中。**Spring容器的BeanDefinitionRegistry就像是Spring配置信息的内存数据库，**主要是以map的形式保存，后续操作直接从BeanDefinitionRegistry中读取配置信息。它们之间的关系如下图所示：

因此，要解析属性首先要创建用于承载属性的实例，也就是创建GenricBeanDefinition类型的实例，而代码就是:

AbstractBeanDefinition bd = createBeanDefinition(className, parent);

这行代码的作用就是实现了此功能，我们详细看一下该方法体：

看源码(
```
BeanDefinitionParserDelegate.java
```
)

protected AbstractBeanDefinition createBeanDefinition(@Nullable String className, @Nullable String parentName)throws ClassNotFoundException {// 这里 创建了 GenericBeanDefinition 实例 在 BeanDefinitionReaderUtils 中实现return BeanDefinitionReaderUtils.createBeanDefinition(parentName, className, this.readerContext.getBeanClassLoader());}

看源码(
```
BeanDefinitionReaderUtils.java
```
)

public static AbstractBeanDefinition createBeanDefinition(@Nullable String parentName, @Nullable String className, @Nullable ClassLoader classLoader) throws ClassNotFoundException {GenericBeanDefinition bd = new GenericBeanDefinition();bd.setParentName(parentName);if (className != null) {if (classLoader != null) {bd.setBeanClass(ClassUtils.forName(className, classLoader));} else {bd.setBeanClassName(className);}}return bd;}

当我们创建好了承载Bean信息的实例后，接下来就是解析各种属性了。我们继续回到BeanDefinitionParserDelegate类中的parseBeanDefinitionElement方法中看下一步的对各种属性解析。

各种属性的解析

看源码(
```
BeanDefinitionParserDelegate.java
```
)

public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,@Nullable BeanDefinition containingBean, AbstractBeanDefinition bd) {// 解析 singleton属性if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {error("Old 1.x \'singleton\' attribute in use - upgrade to \'scope\' declaration", ele);}// 解析scope属性 else if (ele.hasAttribute(SCOPE_ATTRIBUTE)) {bd.setScope(ele.getAttribute(SCOPE_ATTRIBUTE));} else if (containingBean != null) {// Take default from containing bean in case of an inner bean definition.bd.setScope(containingBean.getScope());}// 解析abstract属性if (ele.hasAttribute(ABSTRACT_ATTRIBUTE)) {bd.setAbstract(TRUE_VALUE.equals(ele.getAttribute(ABSTRACT_ATTRIBUTE)));}// 解析 lazyInit 属性String lazyInit = ele.getAttribute(LAZY_INIT_ATTRIBUTE);if (isDefaultValue(lazyInit)) {lazyInit = this.defaults.getLazyInit();}bd.setLazyInit(TRUE_VALUE.equals(lazyInit));// 解析 autowire 属性String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);bd.setAutowireMode(getAutowireMode(autowire));// 解析 dependsOn 属性if (ele.hasAttribute(DEPENDS_ON_ATTRIBUTE)) {String dependsOn = ele.getAttribute(DEPENDS_ON_ATTRIBUTE);bd.setDependsOn(StringUtils.tokenizeToStringArray(dependsOn, MULTI_VALUE_ATTRIBUTE_DELIMITERS));}// 解析 autowireCandidate 属性String autowireCandidate = ele.getAttribute(AUTOWIRE_CANDIDATE_ATTRIBUTE);if (isDefaultValue(autowireCandidate)) {String candidatePattern = this.defaults.getAutowireCandidates();if (candidatePattern != null) {String[] patterns = StringUtils.commaDelimitedListToStringArray(candidatePattern);bd.setAutowireCandidate(PatternMatchUtils.simpleMatch(patterns, beanName));}} else {bd.setAutowireCandidate(TRUE_VALUE.equals(autowireCandidate));}// 解析 primary 属性if (ele.hasAttribute(PRIMARY_ATTRIBUTE)) {bd.setPrimary(TRUE_VALUE.equals(ele.getAttribute(PRIMARY_ATTRIBUTE)));}// 解析init_method属性if (ele.hasAttribute(INIT_METHOD_ATTRIBUTE)) {String initMethodName = ele.getAttribute(INIT_METHOD_ATTRIBUTE);bd.setInitMethodName(initMethodName);} else if (this.defaults.getInitMethod() != null) {bd.setInitMethodName(this.defaults.getInitMethod());bd.setEnforceInitMethod(false);}// 解析destroy_method属性if (ele.hasAttribute(DESTROY_METHOD_ATTRIBUTE)) {String destroyMethodName = ele.getAttribute(DESTROY_METHOD_ATTRIBUTE);bd.setDestroyMethodName(destroyMethodName);} else if (this.defaults.getDestroyMethod() != null) {bd.setDestroyMethodName(this.defaults.getDestroyMethod());bd.setEnforceDestroyMethod(false);}// 解析factory_method属性if (ele.hasAttribute(FACTORY_METHOD_ATTRIBUTE)) {bd.setFactoryMethodName(ele.getAttribute(FACTORY_METHOD_ATTRIBUTE));}// 解析factory_bean 属性if (ele.hasAttribute(FACTORY_BEAN_ATTRIBUTE)) {bd.setFactoryBeanName(ele.getAttribute(FACTORY_BEAN_ATTRIBUTE));}return bd;}

解析完了Bean的各种属性，接下来又做了设置description，这里不展开说这个，紧接着又做了解析meta元素。我们来看一下

解析meta元素

看源码(
```
BeanDefinitionParserDelegate.java
```
)

public void parseMetaElements(Element ele, BeanMetadataAttributeAccessor attributeAccessor) {NodeList nl = ele.getChildNodes();for (int i = 0; i < nl.getLength(); i++) {Node node = nl.item(i);if (isCandidateElement(node) && nodeNameEquals(node, META_ELEMENT)) {Element metaElement = (Element) node;String key = metaElement.getAttribute(KEY_ATTRIBUTE);String value = metaElement.getAttribute(VALUE_ATTRIBUTE);BeanMetadataAttribute attribute = new BeanMetadataAttribute(key, value);attribute.setSource(extractSource(metaElement));attributeAccessor.addMetadataAttribute(attribute);}}}

简单说一下meta元素的使用，demo如下：

<bean id="demo" class="com.vipbbo.hellospring.demo"><property name="beanName" value="bean demo1"/><meta key="demo" value="demo"/></bean>

这段代码并不会体现在demo属性中，而是一个额外的声明，如果需要用到这里的信息可以通过BeanDefinition的getAttribute()方法获取。

解析replaced-method属性

在分析代码之前我么先简单的了解一下

replaced-method

的用法，其主要功能是方法替换，即在运行时用新的方法替换旧的方法，与之前的

lookup-method

方法不同的是此方法不仅可以替换返回的bean，话可以动态的更改原有方法的运行逻辑，demo如下：

package com.vipbbo.spring.bean.replacedmethod;/*** 解析replaced-method属性* 其主要功能是方法替换：即在运行时用新的方法替换旧的方法。* 与之前的lookup-method不同的是此方法不仅可以替换返回的bean，还可以动态的更改原有方法的运行逻辑* @author paidaxing*/public class TestChangeMethod {public void changeMe(){System.out.println("ChangeMe");}}

/*** 新的实现方法*/public class ReplacerChangeMethod implements MethodReplacer {@Overridepublic Object reimplement(Object obj, Method method, Object[] args) throws Throwable {System.out.println("I Replace Method");return null;}}

配置文件：

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"><!-- 该配置文件主要是测试 解析replaced-method属性  --><bean id="changeMe" class="com.vipbbo.spring.bean.replacedmethod.TestChangeMethod"><replaced-method name="changeMe" replacer="replacer"/></bean><bean id="replacer" class="com.vipbbo.spring.bean.replacedmethod.ReplacerChangeMethod"/></beans>

测试方法：

public class TestReplacedMethod {@Testpublic void testReplaceMethod(){ApplicationContext ac =new ClassPathXmlApplicationContext("replaced-method.xml");TestChangeMethod changeMe = (TestChangeMethod) ac.getBean("changeMe");changeMe.changeMe();}}

接下来我们看下解析replaced-method的方法代码：

看源码(
```
BeanDefinitionParserDelegate.java
```
)

public void parseReplacedMethodSubElements(Element beanEle, MethodOverrides overrides) {NodeList nl = beanEle.getChildNodes();for (int i = 0; i < nl.getLength(); i++) {Node node = nl.item(i);if (isCandidateElement(node) && nodeNameEquals(node, REPLACED_METHOD_ELEMENT)) {Element replacedMethodEle = (Element) node;String name = replacedMethodEle.getAttribute(NAME_ATTRIBUTE);String callback = replacedMethodEle.getAttribute(REPLACER_ATTRIBUTE);ReplaceOverride replaceOverride = new ReplaceOverride(name, callback);// Look for arg-type match elements.List<Element> argTypeEles = DomUtils.getChildElementsByTagName(replacedMethodEle, ARG_TYPE_ELEMENT);for (Element argTypeEle : argTypeEles) {String match = argTypeEle.getAttribute(ARG_TYPE_MATCH_ATTRIBUTE);match = (StringUtils.hasText(match) ? match : DomUtils.getTextValue(argTypeEle));if (StringUtils.hasText(match)) {replaceOverride.addTypeIdentifier(match);}}replaceOverride.setSource(extractSource(replacedMethodEle));overrides.addOverride(replaceOverride);}}}

我们可以看到无论是 look-up 还是 replaced-method 是构造了 MethodOverride ，并最终记录在了 AbstractBeanDefinition 中的 methodOverrides 属性中.

解析constructor-arg

对于构造函数的解析是比较重要的，也是非常复杂的，

看源码(
```
BeanDefinitionParserDelegate.java
```
)

public void parseConstructorArgElements(Element beanEle, BeanDefinition bd) {NodeList nl = beanEle.getChildNodes();for (int i = 0; i < nl.getLength(); i++) {Node node = nl.item(i);if (isCandidateElement(node) && nodeNameEquals(node, CONSTRUCTOR_ARG_ELEMENT)) {parseConstructorArgElement((Element) node, bd);}}}

/*** Parse a constructor-arg element.*/public void parseConstructorArgElement(Element ele, BeanDefinition bd) {// 提取 index 属性String indexAttr = ele.getAttribute(INDEX_ATTRIBUTE);// 提取 type 属性String typeAttr = ele.getAttribute(TYPE_ATTRIBUTE);// 提取 name 属性String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);if (StringUtils.hasLength(indexAttr)) {try {int index = Integer.parseint(indexAttr);if (index < 0) {error("\'index\' cannot be lower than 0", ele);} else {try {this.parseState.push(new ConstructorArgumentEntry(index));// 解析 ele 对应的元素属性Object value = parsePropertyValue(ele, bd, null);ConstructorArgumentValues.ValueHolder valueHolder = new ConstructorArgumentValues.ValueHolder(value);if (StringUtils.hasLength(typeAttr)) {valueHolder.setType(typeAttr);}if (StringUtils.hasLength(nameAttr)) {valueHolder.setName(nameAttr);}valueHolder.setSource(extractSource(ele));if (bd.getConstructorArgumentValues().hasIndexedArgumentValue(index)) {error("Ambiguous constructor-arg entries for index " + index, ele);} else {bd.getConstructorArgumentValues().addIndexedArgumentValue(index, valueHolder);}}finally {this.parseState.pop();}}}catch (NumberFormatException ex) {error("Attribute \'index\' of tag \'constructor-arg\' must be an integer", ele);}} else {try {this.parseState.push(new ConstructorArgumentEntry());Object value = parsePropertyValue(ele, bd, null);ConstructorArgumentValues.ValueHolder valueHolder = new ConstructorArgumentValues.ValueHolder(value);if (StringUtils.hasLength(typeAttr)) {valueHolder.setType(typeAttr);}if (StringUtils.hasLength(nameAttr)) {valueHolder.setName(nameAttr);}valueHolder.setSource(extractSource(ele));bd.getConstructorArgumentValues().addGenericArgumentValue(valueHolder);}finally {this.parseState.pop();}}}

源码分析

上述的代码可以简单梳理一下，主要分为以下几步

首先提取index、type、name等属性
根据是否配置了index属性解析流程不同

如果配置了index属性，解析流程如下：

使用parsePropertyValue(ele, bd, null)方法读取constructor-arg的子元素
使用ConstructorArgumentValues.ValueHolder封装解析出来的元素
将index、type、name属性也封装进ValueHolder中，然后将ValueHolder添加到当前beanDefinition的ConstructorArgumentValues的IndexedArgumentValue，而IndexedArgumentValue也是一个map类型。

如果没有配置index属性，将index、type、name属性也封装进ValueHolders中，然后将ValueHolder添加到当前beanDefinition的ConstructorArgumentValues的GenericArgumentValue中，

接下来我们看一下解析ele对应元素的属性方法

看源码(
```
BeanDefinitionParserDelegate.java
```
)

@Nullablepublic Object parsePropertyValue(Element ele, BeanDefinition bd, @Nullable 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);// 略过 description 和 meta属性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;}}}// 解析 ref 属性Boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE);// 解析 value 属性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);}if (hasRefAttribute) {String refName = ele.getAttribute(REF_ATTRIBUTE);if (!StringUtils.hasText(refName)) {error(elementName + " contains empty \'ref\' attribute", ele);}// 使用 RuntimeBeanReference 来封装ref对应的BeanRuntimeBeanReference ref = new RuntimeBeanReference(refName);ref.setSource(extractSource(ele));return ref;} else if (hasValueAttribute) {// 使用 TypStringValue 来封装value属性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;}}

源码分析

针对上述代码逻辑进行一个简单的梳理

首先略过description和mate属性
提取constructor-arg上的ref和value属性，并验证是否存在
存在ref属性，用RuntimeBeanReference来封装ref
存在value属性时，用TypeStringValue来封装
存在子元素时，对于子元素的处理使用了方法parsePropertySubElement(subElement, bd);进行处理，其源码如下：

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

@Nullablepublic Object parsePropertySubElement(Element ele, @Nullable BeanDefinition bd, @Nullable String defaultValueType) {// 判断是否是默认标签处理if (!isDefaultNamespace(ele)) {return parseNestedCustomElement(ele, bd);}// 对于Bean 标签的处理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 a parent context.refName = ele.getAttribute(PARENT_REF_ATTRIBUTE);toParent = true;if (!StringUtils.hasLength(refName)) {error("\'bean\' or \'parent\' is required for <ref> element", ele);return null;}}if (!StringUtils.hasText(refName)) {error("<ref> element contains empty target attribute", ele);return null;}RuntimeBeanReference ref = new RuntimeBeanReference(refName, toParent);ref.setSource(extractSource(ele));return ref;}// idref元素处理else if (nodeNameEquals(ele, IDREF_ELEMENT)) {return parseIdRefElement(ele);}// value 元素处理else if (nodeNameEquals(ele, VALUE_ELEMENT)) {return parseValueElement(ele, defaultValueType);}// NULL 元素处理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;}// array 元素处理else if (nodeNameEquals(ele, ARRAY_ELEMENT)) {return parseArrayElement(ele, bd);}// list 元素处理else if (nodeNameEquals(ele, LIST_ELEMENT)) {return parseListElement(ele, bd);}// set 元素处理else if (nodeNameEquals(ele, SET_ELEMENT)) {return parseSetElement(ele, bd);}// map 元素处理else if (nodeNameEquals(ele, MAP_ELEMENT)) {return parseMapElement(ele, bd);}// props 元素处理else if (nodeNameEquals(ele, PROPS_ELEMENT)) {return parsePropsElement(ele);} else {error("Unknown property sub-element: [" + ele.getNodeName() + "]", ele);return null;}}

解析properties子元素

接下来再回到BeanDefinitionParserDelegate类中的parseBeanDefinitionElement方法

看一下子元素properties的解析

看源码(
```
BeanDefinitionParserDelegate.java
```
)

public void parsePropertyElements(Element beanEle, BeanDefinition bd) {NodeList nl = beanEle.getChildNodes();for (int i = 0; i < nl.getLength(); i++) {Node node = nl.item(i);if (isCandidateElement(node) && nodeNameEquals(node, PROPERTY_ELEMENT)) {parsePropertyElement((Element) node, bd);}}}

public void parsePropertyElement(Element ele, BeanDefinition bd) {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 {// 不允许对同一属性多次配置if (bd.getPropertyValues().contains(propertyName)) {error("Multiple \'property\' definitions for property \'" + propertyName + "\'", ele);return;}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();}}

源码分析

代码的逻辑非常简单，在获取了propertie的属性后使用PropertyValue 进行封装，然后将其添加到BeanDefinition的propertyValueList中

解析子元素Qualifier

接下来再回到BeanDefinitionParserDelegate类中的parseBeanDefinitionElement方法

看一下子元素Qualifier的解析

对于Qualifier元素的获取，我们接触更多的就是注解的形式，在使用Spring框架中进行自动注入时，Spring容器中匹配候选Bean数目必须有且仅有一个，当找不到一个匹配的Bean时，Spring容器将抛出BeanCreationException异常，并指出必须至少拥有一个匹配的Bean。

Spring允许我们通过Qualifier指定注入Bean的名称，这样歧义就消除了，配置方式如下：

<bean id="myTestBean" class="com.vipbbo.hellospring.MyTestBean"><qualifier  type="org.Springframework.beans.factory.annotation.Qualifier" value="gf" /></bean>

其解析过程与之前大同小异这里不再赘述；

至此我们完成了对XML文档到GenericBeanDefinition的转换，也就是说，XML中所有配置都可以在GenericBeanDefinition的实例类中找到对应的配置。

GenericBeanDefinition只是子类实现，而大部分的通用性都保存在了AbstractBeanDefinition中。那么再次通过AbstractBeanDefinition的属性来回顾以下我们都解析了哪些对应的配置

看源码(
```
AbstractBeanDefinition.java
```
)

public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessorimplements BeanDefinition, Cloneable {// 此处省略final修饰的..../*** Bean 的作用范围，对应bean 属性 scope*/@Nullableprivate String scope = SCOPE_DEFAULT;/*** 是否是抽象，对应bean属性 abstract*/private Boolean abstractFlag = false;/*** 是否延迟加载，对应bean属性 lazy-init*/@Nullableprivate Boolean lazyInit;/*** 自动注入模式，对应bean属性autowire*/private int autowireMode = AUTOWIRE_NO;/*** 依赖检查，Spring3.0 后弃用这个属性*/private int dependencyCheck = DEPENDENCY_CHECK_NONE;/*** 用来表示bean的实例化依赖于另外一个bean的先实例化，对应bean属性 depend-on*/@Nullableprivate String[] dependsOn;/*** autowireCandidate属性设置为false，这样容器在查找自动装配对象时，将不考虑该Bean，即它不会被考虑作为其它bean自动装配的候选者* 但是该bean本身还是可以使用自动装配来注入其它的bean*/private Boolean autowireCandidate = true;/*** 自动装配出现多个bean候选者时，将作为首选者，对应的bean属性 primary*/private Boolean primary = false;/*** 用于记录Qualifier，对应的子元素qualifier*/private final Map<String, AutowireCandidateQualifier> qualifiers = new LinkedHashMap<>();@Nullableprivate Supplier<?> instanceSupplier;/*** 允许访问非公开的构造器和方法，程序设置*/private Boolean nonPublicAccessAllowed = true;/*** 是否以一种宽松模式解析构造函数，默认为true，* 如果为false，则在以下情况：*         interface ITest{}*         Class ITestImpl implements ITest(){};*         Class Main{*              Main(ITest i) {}*              Main(ITestImpl i) {}*         }*     抛出异常，因为Spring无法精确定位哪个构造函数程序设置*/private Boolean lenientConstructorResolution = true;/*** 对应bean属性 factory-bean 。 用法：*         <bean id = "instanceFactoryBean" class = "example.chapter3.InstanceFactoryBean" />*         <bean id = "currentTime" factory-bean = "instanceFactoryBean" factory-method = "createTime" />*/@Nullableprivate String factoryBeanName;/*** 对应bean属性 factory-method*/@Nullableprivate String factoryMethodName;/*** 记录构造函数注入属性：对应bean属性 constructor-arg*/@Nullableprivate ConstructorArgumentValues constructorArgumentValues;/*** 普通属性集合*/@Nullableprivate MutablePropertyValues propertyValues;/*** 方法重写的持有者，记录lookup-method、replace-method元素*/private MethodOverrides methodOverrides = new MethodOverrides();/*** 初始化方法，对应bean属性 init-method*/@Nullableprivate String initMethodName;/*** 销毁方法，对应bean属性 destory-method*/@Nullableprivate String destroyMethodName;/*** 是否执行 init-method，程序设置*/private Boolean enforceInitMethod = true;/*** 是否执行 destory-method，程序设置*/private Boolean enforceDestroyMethod = true;/*** 是否是用户定义的，而不是应用程序本身定义的，创建AOP时候为true，程序设置*/private Boolean synthetic = false;/*** 定义这个bean应用：ROLE_APPLICATION：用户；ROLE_INFRASTRUCTURE 完全内部使用，与用户无关；ROLE_SUPPORT：某些复杂配置的一部分* 程序设置*/private int role = BeanDefinition.ROLE_APPLICATION;/*** bean的描述信息*/@Nullableprivate String description;/*** 这个bean定义的资源*/@Nullableprivate Resource resource;// 省略后面的...}

讲到这里关于BeanDefinition的解析就告一段落了。大家可以根据以下目录取回顾以下上述的流程