Spring Bean註冊解析(二)
在上文Spring Bean註冊解析(一)中，咱們講解了Spring在註冊Bean以前進行了哪些前期工做，以及Spring是如何存儲註冊的Bean的，而且詳細介紹了Spring是如何解析xml文件的四種基本標籤中的import、alias和beans標籤的，本文主要講解Spring是如何解析xml文件中的bean標籤。java
咱們首先仍是來看Spring解析四種基本標籤的入口，及DefaultBeanDefinitionDocumentReader.parseDefaultElement方法：node
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()方法中，其主要分爲三步：ide
- 對基本的bean標籤屬性及子節點進行解析；
- 將解析獲得的BeanDefinitionHolder對象進行修飾，其主要是根據自定義的屬性和子標籤來進一步豐富當前BeanDefinition的屬性；
- 將BeanDefinition註冊到BeanDefinitionRegistry中。
這裏須要注意的是BeanDefinitionHolder只是BeanDefinition的一個容器，在BeanDefinitionRegistry中註冊的實際上是BeanDefinition。ui
這裏咱們主要看解析bean基本屬性的BeanDefinitionParserDelegate.parseBeanDefinitionElement()方法，關於對BeanDefinition進行修飾的BeanDefinitionParserDelegate.decorateBeanDefinitionIfRequired()，其主要涉及到了自定義標籤的使用和解析，這與上文中所講的自定義標籤的解析是一致的，咱們將在下一篇文章中進行講解。以下是parseBeanDefinitionElement()的實現：this
@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()方法，以下是該方法的源碼：spa
@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()方法：prototype
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()方法：debug
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的方式。
相關文章
- 1. Spring 中 bean 註冊的源碼解析
- 2. spring源碼閱讀之BeanDefinition，解析文件，讀取Bean，解析Bean，註冊Bean
- 3. Spring源碼-IOC容器(二)-Bean的定位解析註冊
- 4. spring註解開發（一） bean的註冊
- 5. Spring源碼深度解析-bean標籤的解析及註冊
- 6. Spring之動態註冊bean
- 7. 四、Spring-bean組件註冊
- 8. Spring IoC 源碼分析 (基於註解) 之 Bean的解析與註冊
- 9. bean標籤的解析及註冊——BeanDefinitionHolder
- 10. bean標籤的解析及註冊-BeanDefintion
- 更多相關文章...
- • XML DOM 解析器 - XML DOM 教程
- • Spring基於Annotation裝配Bean - Spring教程
- • Spring Cloud 微服務實戰(三) - 服務註冊與發現
- • RxJava操作符（二）Transforming Observables
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. Spring 中 bean 註冊的源碼解析
- 2. spring源碼閱讀之BeanDefinition，解析文件，讀取Bean，解析Bean，註冊Bean
- 3. Spring源碼-IOC容器(二)-Bean的定位解析註冊
- 4. spring註解開發（一） bean的註冊
- 5. Spring源碼深度解析-bean標籤的解析及註冊
- 6. Spring之動態註冊bean
- 7. 四、Spring-bean組件註冊
- 8. Spring IoC 源碼分析 (基於註解) 之 Bean的解析與註冊
- 9. bean標籤的解析及註冊——BeanDefinitionHolder
- 10. bean標籤的解析及註冊-BeanDefintion