???????在上文Spring Bean注冊解析(一)中，我們講解了Spring在注冊Bean之前進行了哪些前期工作，以及Spring是如何存儲注冊的Bean的，并且詳細介紹了Spring是如何解析xml文件的四種基本標簽中的import、alias和beans標簽的，本文主要講解Spring是如何解析xml文件中的bean標簽。
???????我們首先還是來看Spring解析四種基本標簽的入口，及DefaultBeanDefinitionDocumentReader.parseDefaultElement方法：
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)) {
processBeanDefinition(ele, delegate);
}
else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
// recurse
doRegisterBeanDefinitions(ele);
}
}
???????其余三種標簽的解析過程上文已經進行了講解，這里不再贅述，我們直接進入processBeanDefinition()方法：
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
// 對基本的bean標簽屬性進行解析
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if (bdHolder != null) {
// 對自定義的屬性或者自定義的子節點進行解析，以豐富當前的BeanDefinition
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
// 將當前bean注冊到BeanDefinitionRegistry中
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
}
catch (BeanDefinitionStoreException ex) {
getReaderContext().error("Failed to register bean definition with name '" +
bdHolder.getBeanName() + "'", ele, ex);
}
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
}
???????在processBeanDefinition()方法中，其主要分為三步：
- 對基本的bean標簽屬性及子節點進行解析；
- 將解析得到的BeanDefinitionHolder對象進行修飾，其主要是根據自定義的屬性和子標簽來進一步豐富當前BeanDefinition的屬性；
- 將BeanDefinition注冊到BeanDefinitionRegistry中。
???????這里需要注意的是BeanDefinitionHolder只是BeanDefinition的一個容器，在BeanDefinitionRegistry中注冊的其實是BeanDefinition。
???????這里我們主要看解析bean基本屬性的BeanDefinitionParserDelegate.parseBeanDefinitionElement()方法，關于對BeanDefinition進行修飾的BeanDefinitionParserDelegate.decorateBeanDefinitionIfRequired()，其主要涉及到了自定義標簽的使用和解析，這與上文中所講的自定義標簽的解析是一致的，我們將在下一篇文章中進行講解。如下是parseBeanDefinitionElement()的實現：
@Nullable
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
// 獲取bean標簽的id屬性值
String id = ele.getAttribute(ID_ATTRIBUTE);
// 獲取bean標簽的name屬性值
String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
// 對name屬性值按照逗號和分號進行分割，將分割后的所有name屬性值作為當前bean的別名
List<String> aliases = new ArrayList<>();
if (StringUtils.hasLength(nameAttr)) {
String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
aliases.addAll(Arrays.asList(nameArr));
}
// 以id屬性的值作為當前bean的默認名稱，如果沒有id屬性，那么將name屬性的第一個值作為當前bean的名稱
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");
}
}
// 檢查當前bean的名稱與已經解析的bean名稱是否有相同的，如果有相同的則拋出異常，保證所有不同bean的名稱和別名相互之間不相同
if (containingBean == null) {
checkNameUniqueness(beanName, aliases, ele);
}
// 對bean標簽中的各個屬性以及子標簽進行解析
AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
if (beanDefinition != null) {
// 如果沒有指定id或name屬性，則為當前bean自動生成名稱
if (!StringUtils.hasText(beanName)) {
try {
// 如果父bean為空，那么按照默認方式生成bean名稱
if (containingBean != null) {
beanName = BeanDefinitionReaderUtils.generateBeanName(
beanDefinition, this.readerContext.getRegistry(), true);
} else {
// 如果父bean不為空，則生成名稱時按照一定規則將父bean加入生成的bean名稱中
beanName = this.readerContext.generateBeanName(beanDefinition);
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;
}
}
// 將生成的BeanDefinition，beanName和alias封裝到BeanDefinitionHolder中
String[] aliasesArray = StringUtils.toStringArray(aliases);
return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
}
return null;
}
???????可以看到parseBeanDefinitionElement()方法首先會獲取當前bean的id和name屬性值，默認以id屬性作為bean的名稱，如果沒有則將name屬性值按照逗號或分號分割，并分割后的第一個值作為bean的名稱，其余的值作為別名，如果id和name屬性都存在，那么將name屬性分割后的所有值都作為別名。這里在處理完id和name屬性后，會對生成的bean名稱和別名進行檢查，以保證所有bean的名稱和別名相互之間不能重復。接著通過parseBeanDefinitionElement()方法對bean的其他屬性進行解析，從而生成一個BeanDefinition對象。解析完之后會檢查如果當前bean還是沒有名稱，則按照上述的規則為bean生成一個默認名稱。我們這里主要看parseBeanDefinitionElement()方法，如下是該方法的源碼：
@Nullable
public AbstractBeanDefinition parseBeanDefinitionElement(
Element ele, String beanName, @Nullable BeanDefinition containingBean) {
// 將當前bean的名稱push到parseState屬性中，以標識當前beanName的bean正在被解析
this.parseState.push(new BeanEntry(beanName));
// 獲取class屬性的值
String className = null;
if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
}
// 獲取parent屬性的值
String parent = null;
if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
parent = ele.getAttribute(PARENT_ATTRIBUTE);
}
try {
// 創建一個BeanDefinition的對象
AbstractBeanDefinition bd = createBeanDefinition(className, parent);
// 轉換基本的bean屬性的值
parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
// 轉換并封裝元節點標簽
parseMetaElements(ele, bd);
// 轉換lookup-method子標簽，將其封裝到MethodOverrides對象中
parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
// 轉換replaced-method子標簽，也將其封裝到MethodOverrides對象中
parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
// 解析并且封裝constructor-arg子標簽到BeanDefinition中
parseConstructorArgElements(ele, bd);
// 解析并且封裝property子標簽到BeanDefinition中
parsePropertyElements(ele, bd);
// 解析并且封裝qualifier子標簽到BeanDefinition中
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;
}
???????可以看到，parseBeanDefinitionElement()首先是獲取class和parent屬性值，并將其封裝到BeanDefinition中，然后是解析bean標簽的基本屬性值，接著是解析bean標簽的子標簽，如元節點、lookup-method、replaced-method、constructor-arg等。我們首先看parseBeanDefinitionAttributes()方法：
public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,
@Nullable BeanDefinition containingBean, AbstractBeanDefinition bd) {
// 檢查當前bean是否有singleton屬性，有則提示應該使用scope屬性，并拋出異常
if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {
error("Old 1.x 'singleton' attribute in use - upgrade to 'scope' declaration",
ele);
}
else if (ele.hasAttribute(SCOPE_ATTRIBUTE)) {
// 獲取并設置scope屬性值
bd.setScope(ele.getAttribute(SCOPE_ATTRIBUTE));
}
else if (containingBean != null) {
// 沒有scope屬性值，則將父bean的scope屬性設置給當前bean
bd.setScope(containingBean.getScope());
}
// 獲取并設置abstract屬性值
if (ele.hasAttribute(ABSTRACT_ATTRIBUTE)) {
bd.setAbstract(TRUE_VALUE.equals(ele.getAttribute(ABSTRACT_ATTRIBUTE)));
}
// 獲取并設置lazy-init屬性值，如果當前bean的lazy-init是默認值，
// 則將beans標簽中設置的lazy-init屬性值設置給當前bean
String lazyInit = ele.getAttribute(LAZY_INIT_ATTRIBUTE);
if (DEFAULT_VALUE.equals(lazyInit)) {
lazyInit = this.defaults.getLazyInit();
}
bd.setLazyInit(TRUE_VALUE.equals(lazyInit));
// 獲取并設置autowire屬性值
String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);
bd.setAutowireMode(getAutowireMode(autowire));
// 獲取depends-on屬性值，并且按照逗號或分號進行分割，然后設置depends-on屬性值
if (ele.hasAttribute(DEPENDS_ON_ATTRIBUTE)) {
String dependsOn = ele.getAttribute(DEPENDS_ON_ATTRIBUTE);
bd.setDependsOn(StringUtils.tokenizeToStringArray(dependsOn,
MULTI_VALUE_ATTRIBUTE_DELIMITERS));
}
// 獲取并設置autowire-candicate屬性值，如果其為空，那么獲取當前xml
// 最外層beans標簽設置的autowire-candicate屬性值，并將其設置給當前bean
String autowireCandidate = ele.getAttribute(AUTOWIRE_CANDIDATE_ATTRIBUTE);
if ("".equals(autowireCandidate) || DEFAULT_VALUE.equals(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屬性值，如果該屬性為空，
// 則獲取當前xml最外層beans標簽設置的init-method屬性值，并且設置給當前bean
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屬性的值，如果該屬性值為空，
// 則獲取當前xml最外層beans標簽設置的destroy-method屬性值，并設置給當前bean
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);
}
// 獲取并設置fatory-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;
}
???????可以看到，parseBeanDefinitionAttributes()方法主要是獲取當前bean標簽的各個節點的屬性值，并且將其設置給當前的BeanDefinition。對于部分屬性，如：init-method、autowire等，如果其值為空，則會獲取當前xml最外層beans標簽對應的屬性值，并將其設置給當前bean。接下來我們看parseMetaElements()方法：
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子標簽，其主要有key和value兩個屬性值，用于保存一些元數據，以供給后續自定義Spring功能或者在相關的請求中獲取使用。這里可以看到，對meta標簽的解析也只是將其屬性值獲取到之后封裝到BeanMetadataAttribute對象中，并且添加到BeanMetadataAttributeAccessor中。接著我們看看parseLookupOverrideSubElements()方法：
public void parseLookupOverrideSubElements(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, LOOKUP_METHOD_ELEMENT)) {
Element ele = (Element) node;
String methodName = ele.getAttribute(NAME_ATTRIBUTE);
String beanRef = ele.getAttribute(BEAN_ELEMENT);
LookupOverride override = new LookupOverride(methodName, beanRef);
override.setSource(extractSource(ele));
overrides.addOverride(override);
}
}
}
???????可以看到，parseLookupOverrideSubElements()方法首先會獲取當前bean標簽的所有子標簽，然后遍歷判斷是否有定義lookup-method子標簽，如果有定義，則獲取其name屬性和bean屬性的值，并且封裝到LookupOverride對象中。這里需要說明下lookup-method方法的作用：如果一個bean A依賴了另一個bean B，但是B并不是單例的，比如是prototype類型的，那么每次獲取B的時候都需要在A中通過ApplicationContext獲取，這就使得A依賴了本不屬于自己的屬性ApplicationContext，這里我們可以使用lookup-method標簽處理這個問題，該標簽name屬性指定了獲取指定bean的方法名，而bean標簽則指定了目標bean的名稱，使用方式如下：
<bean id="a" class="com.A">
<lookup-method name="getB" bean="b"/>
</bean>
???????這里getB方法是在類A中定義的一個抽象。接下來我們看看parseReplacedMethodSubElements()方法：
public void parseReplacedMethodSubElements(Element beanEle, MethodOverrides overrides) {
NodeList nl = beanEle.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
// 查找replaced-method子標簽
if (isCandidateElement(node) && nodeNameEquals(node, REPLACED_METHOD_ELEMENT)) {
Element replacedMethodEle = (Element) node;
// 獲取name屬性和replacer屬性的值
String name = replacedMethodEle.getAttribute(NAME_ATTRIBUTE);
String callback = replacedMethodEle.getAttribute(REPLACER_ATTRIBUTE);
// 將name屬性和replacer屬性的值封裝到ReplaceOverride對象中
ReplaceOverride replaceOverride = new ReplaceOverride(name, callback);
// 獲取并且封裝arg-type子標簽的屬性
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);
}
}
}
???????在parseReplacedMethodSubElements()方法中，其首先會遍歷bean標簽的所有子標簽，判斷其是否為replaced-method子標簽，然后獲取該標簽的name和replacer屬性的值，并且封裝到ReplaceOverride對象中，接著解析當前replaced-method標簽是否有arg-type子標簽，該子標簽用于標識當前replaced-method的參數類型，如果有則將其設置到ReplaceOverride中。
???????這里需要說明的是，replaced-method方法主要用于在運行時動態地替換目標方法的。比如類A有一個方法methodA()，但其實現的功能并不能滿足要求，那么我們可以聲明一個實現了MethodReplacer接口的bean B，并使用replaced-method標簽替換bean A的methodA()的執行。replaced-method的具體用法如下：
<bean id="a" class="com.A">
<replaced-method name="methodA" replacer="b"/>
</bean>
<bean id="b" class="com.B"/>
???????這里B是一個實現了MethodReplacer接口的類，如：
public class B implements MethodReplacer {
@Override
public Object reimplement(Object obj, Method method, Object[] args) throws Throwable{
System.out.println("this is method in B.");
}
}
???????這樣在調用bean A的methodA時，其實際會被替換為調用B的reimplement()方法。接下來我們看看parseConstructorArgElements()方法：
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);
}
}
}
???????在parseConstructorArgElements()方法中，其只會解析第一個遇到的constructor-arg子標簽，具體的解析過程在parseConstructorArgElement()方法，如下是該方法的實現：
public void parseConstructorArgElement(Element ele, BeanDefinition bd) {
// 獲取index，type和name屬性值
String indexAttr = ele.getAttribute(INDEX_ATTRIBUTE);
String typeAttr = ele.getAttribute(TYPE_ATTRIBUTE);
String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
// 當有index屬性值時的處理方式
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));
// 對屬性值進行解析
Object value = parsePropertyValue(ele, bd, null);
ConstructorArgumentValues.ValueHolder valueHolder = new
ConstructorArgumentValues.ValueHolder(value);
// 封裝type屬性值
if (StringUtils.hasLength(typeAttr)) {
valueHolder.setType(typeAttr);
}
// 封裝name屬性值
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 { // 當沒有index屬性值時的處理方式
try {
this.parseState.push(new ConstructorArgumentEntry());
// 對屬性值進行解析
Object value = parsePropertyValue(ele, bd, null);
// 對解析的屬性值進行封裝
ConstructorArgumentValues.ValueHolder valueHolder = new
ConstructorArgumentValues.ValueHolder(value);
// 設置type屬性值
if (StringUtils.hasLength(typeAttr)) {
valueHolder.setType(typeAttr);
}
// 設置name屬性值
if (StringUtils.hasLength(nameAttr)) {
valueHolder.setName(nameAttr);
}
valueHolder.setSource(extractSource(ele));
bd.getConstructorArgumentValues().addGenericArgumentValue(valueHolder);
}
finally {
this.parseState.pop();
}
}
}
???????我們這里主要看下parsePropertyValue()方法的實現：
@Nullable
public Object parsePropertyValue(Element ele, BeanDefinition bd, @Nullable String propertyName) {
String elementName = (propertyName != null) ?
"<property> element for property '" + propertyName + "'" :
"<constructor-arg> element";
// 判斷當前標簽是否至少有一個非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)) {
// 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和value屬性的值
boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE);
boolean hasValueAttribute = ele.hasAttribute(VALUE_ATTRIBUTE);
// 判斷當前標簽不能同時設置ref和value屬性的值，同時設置了則報錯
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屬性值進行解析
if (hasRefAttribute) {
String refName = ele.getAttribute(REF_ATTRIBUTE);
if (!StringUtils.hasText(refName)) {
error(elementName + " contains empty 'ref' attribute", ele);
}
// 如果是ref屬性值，則將其值封裝為RuntimeBeanReference類型的對象
RuntimeBeanReference ref = new RuntimeBeanReference(refName);
ref.setSource(extractSource(ele));
return ref;
// 如果有value屬性值，則對value屬性值進行處理
} else if (hasValueAttribute) {
// 將value屬性值封裝到TypedStringValue對象中
TypedStringValue valueHolder = new
TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE));
valueHolder.setSource(extractSource(ele));
return valueHolder;
} else if (subElement != null) {
// 如果當前標簽還有子標簽，那么對該子標簽進行解析
return parsePropertySubElement(subElement, bd);
}
else {
// 如果不滿足前面任何一個條件，則拋出異常
error(elementName + " must specify a ref or value", ele);
return null;
}
}
???????可以看到parsePropertyValue()方法只是對當前標簽中存在的屬性進行解析，如果該標簽還有子標簽，則托付給parsePropertySubElement()方法進行解析，如下是該方法的源碼：
@Nullable
public Object parsePropertySubElement(Element ele, @Nullable BeanDefinition bd, @Nullable String defaultValueType) {
// 如果該子標簽使用的自定義的標簽名，則使用自定義子標簽進行解析
if (!isDefaultNamespace(ele)) {
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屬性的值，并且將其封裝到RuntimeBeanReference對象中
String refName = ele.getAttribute(BEAN_REF_ATTRIBUTE);
boolean toParent = false;
if (!StringUtils.hasLength(refName)) {
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;
}
else if (nodeNameEquals(ele, IDREF_ELEMENT)) {
// 如果當前子標簽是idref子標簽，則還是將其封裝到一個RuntimeBeanReference對象中
return parseIdRefElement(ele);
}
else if (nodeNameEquals(ele, VALUE_ELEMENT)) {
// 如果當前子標簽是value子標簽，則將其封裝到一個TypedStringValue對象中，
// 并且會檢查其type屬性指定的class是否存在
return parseValueElement(ele, defaultValueType);
}
else if (nodeNameEquals(ele, NULL_ELEMENT)) {
// 如果子標簽是一個null子標簽，則封裝一個包含空屬性的TypedStringValue對象
TypedStringValue nullHolder = new TypedStringValue(null);
nullHolder.setSource(extractSource(ele));
return nullHolder;
}
else if (nodeNameEquals(ele, ARRAY_ELEMENT)) {
// 如果是array子標簽，則對array子標簽進行解析
return parseArrayElement(ele, bd);
}
else if (nodeNameEquals(ele, LIST_ELEMENT)) {
// 如果是list子標簽，則對list子標簽進行解析
return parseListElement(ele, bd);
}
else if (nodeNameEquals(ele, SET_ELEMENT)) {
// 如果是set子標簽，則對set子標簽進行解析
return parseSetElement(ele, bd);
}
else if (nodeNameEquals(ele, MAP_ELEMENT)) {
// 如果是map子標簽，則對map子標簽進行解析
return parseMapElement(ele, bd);
}
else if (nodeNameEquals(ele, PROPS_ELEMENT)) {
// 如果是props子標簽，則對props子標簽進行解析
return parsePropsElement(ele);
}
else {
error("Unknown property sub-element: [" + ele.getNodeName() + "]", ele);
return null;
}
}
???????如此我們就講解完了對constructor-arg標簽的解析過程。總的來說，constructor-arg標簽的解析首先會解析當前標簽屬性的值，比如index、ref和value等，然后會解析其子標簽的值，子標簽可能為bean，ref，idref以及一些集合類型的屬性，解析完成之后將得到的結果返回。
???????對于parsePropertyElements()方法，其主要是解析property子標簽的，property子標簽的解析與constructor-arg標簽的解析過程非常類似，如果是parsePropertyElements()方法的源碼：
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);
}
}
}
???????可以看到，parsePropertyElements()方法首先會找到標簽名為property的子標簽，然后對其進行解析，解析的方法parsePropertyElement()如下：
public void parsePropertyElement(Element ele, BeanDefinition bd) {
// 獲取name屬性的值
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;
}
// 解析property標簽及其子標簽的值
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();
}
}
???????有了前面對constructor-arg的解析過程，這里property的解析就比較簡單了。parsePropertyElement()方法首先獲取name屬性的值，然后調用前面講的parsePropertyValue()方法對property標簽的其他屬性以及子標簽進行解析，最后將解析結果封裝到PropertyValue對象中。
???????對于qualifier的解析，如下是parseQualifierElements()方法的源碼：
public void parseQualifierElements(Element beanEle, AbstractBeanDefinition bd) {
NodeList nl = beanEle.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
if (isCandidateElement(node) && nodeNameEquals(node, QUALIFIER_ELEMENT)) {
parseQualifierElement((Element) node, bd);
}
}
}
????????可以看到，該方法主要是獲取子標簽名為qualifier的標簽，具體的解析過程在parseQualifierElement()方法中，如下是該方法的源碼：
public void parseQualifierElement(Element ele, AbstractBeanDefinition bd) {
String typeName = ele.getAttribute(TYPE_ATTRIBUTE);
if (!StringUtils.hasLength(typeName)) {
error("Tag 'qualifier' must have a 'type' attribute", ele);
return;
}
this.parseState.push(new QualifierEntry(typeName));
try {
AutowireCandidateQualifier qualifier = new AutowireCandidateQualifier(typeName);
qualifier.setSource(extractSource(ele));
String value = ele.getAttribute(VALUE_ATTRIBUTE);
if (StringUtils.hasLength(value)) {
qualifier.setAttribute(AutowireCandidateQualifier.VALUE_KEY, value);
}
NodeList nl = ele.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
if (isCandidateElement(node) && nodeNameEquals(node,
QUALIFIER_ATTRIBUTE_ELEMENT)) {
Element attributeEle = (Element) node;
String attributeName = attributeEle.getAttribute(KEY_ATTRIBUTE);
String attributeValue = attributeEle.getAttribute(VALUE_ATTRIBUTE);
if (StringUtils.hasLength(attributeName) &&
StringUtils.hasLength(attributeValue)) {
BeanMetadataAttribute attribute = new
BeanMetadataAttribute(attributeName, attributeValue);
attribute.setSource(extractSource(attributeEle));
qualifier.addMetadataAttribute(attribute);
}
else {
error("Qualifier 'attribute' tag must have a 'name' and 'value'",
attributeEle);
return;
}
}
}
bd.addQualifier(qualifier);
}
finally {
this.parseState.pop();
}
}
???????這里對qualifier標簽的解析，首先會獲取其type屬性的值，然后會獲取value屬性的值，并且檢查當前qualifier標簽是否有子標簽，如果有子標簽，則會解析各個子標簽的key和value屬性的值，并且將解析的最終結果封裝到一個AutowireCandidateQualifier對象中。這里需要說明的是，qualifier標簽用于指定當前bean的限定標識符，即另外的bean如果依賴了當前的bean，則可以使用@Qualifier("currentBeanName")來直接引用當前的bean。
???????如此對bean標簽的解析我們就全部講完了，可以看到，Spring對bean的解析主要是將其封裝到BeanDefinition對象中，而bean的實例化則是在后續進行的，BeanDefinition中只是保存了實例化當前bean所需要的必要信息。Spring的這種設計模式也提供給了我們一種定制BeanDefinition的方式。
