【Spring详解三】默认标签的解析

# DefaultBeanDefinitionDocumentReader
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)) {// recursedoRegisterBeanDefinitions(ele);}
}

# DefaultBeanDefinitionDocumentReader
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));}
}

刚开始看这个函数体时一头雾水，没有以前的函数那样的清晰的逻辑，我们细致的理下逻辑，大致流程如下：

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

# BeanDefinitionParserDelegate
public 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.isDebugEnabled()) {......}}// 检查 name 的唯一性if (containingBean == null) {checkNameUniqueness(beanName, aliases, ele);}// 解析 属性，构造 AbstractBeanDefinitionAbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);if (beanDefinition != null) {// 如果 beanName 不存在，则根据Spring中提供的命名规则生成对应的beanNameif (!StringUtils.hasText(beanName)) {try {if (containingBean != null) {beanName = BeanDefinitionReaderUtils.generateBeanName(beanDefinition, this.readerContext.getRegistry(), true);}else {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()) {......}}catch (Exception ex) {......}}String[] aliasesArray = StringUtils.toStringArray(aliases);// 封装 BeanDefinitionHolderreturn new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);}return null;
}

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

# BeanDefinitionParserDelegate
public 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类型的GenericBeanDefinition实例AbstractBeanDefinition bd = createBeanDefinition(className, parent);//硬编码解析bean的各种属性parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);//设置description属性bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));//解析元素parseMetaElements(ele, bd);//解析lookup-method属性parseLookupOverrideSubElements(ele, bd.getMethodOverrides());//解析replace-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;
}

# BeanDefinitionParserDelegate
protected AbstractBeanDefinition createBeanDefinition(@Nullable String className, @Nullable String parentName)throws ClassNotFoundException {return BeanDefinitionReaderUtils.createBeanDefinition(parentName, className, this.readerContext.getBeanClassLoader());
}# BeanDefinitionReaderUtils
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;
}

# BeanDefinitionParserDelegate
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)));}//解析lazy_init属性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));//解析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 ("".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属性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;
}

# BeanDefinitionParserDelegate
public void parseMetaElements(Element ele, BeanMetadataAttributeAccessor attributeAccessor) {// 获取当前节点的所有元素NodeList nl = ele.getChildNodes();for (int i = 0; i < nl.getLength(); i++) {Node node = nl.item(i);// 提取metaif (isCandidateElement(node) && nodeNameEquals(node, META_ELEMENT)) {Element metaElement = (Element) node;String key = metaElement.getAttribute(KEY_ATTRIBUTE);String value = metaElement.getAttribute(VALUE_ATTRIBUTE);// 使用key、value构造BeanMetadataAttributeBeanMetadataAttribute attribute = new BeanMetadataAttribute(key, value);// 记录信息attribute.setSource(extractSource(metaElement));attributeAccessor.addMetadataAttribute(attribute);}}
}

//testLookUp.xml
<bean id="getBeanTest" class="com.xxx.lookupmethod.GetBeanTest"> <lookup-method bean="Kobe" name="getPlayer"/> </bean>
<bean id="Kobe" class="com.xxx.lookupmethod.Kobe"></bean>

//测试类
class Player {public void who () {System.out.println("I am player");}
}
class Kobe {public void who () {System.out.println("I am kobe");}
}
public abstract class GetBeanTest {public void who () {this.getPlayer().who();}public abstract Player getPlayer ();
}class TestMain {public static void main(String[] args) {ApplicationContext applicationContext = new ClassPathXmlApplicationContext("testLookUp.xml");GetBeanTest getBeanTest = applicationContext.getBean("getBeanTest", GetBeanTest.class);getBeanTest.who();}
}

子元素lookup-method似乎并不是很常用，但是在某些时候它的确是非常有用的，通常称它为获取器注入，引用《Spring in Action》中的一句话：获取器注入是一种特殊的方法注入，它是一个方法声明为返回某种类型的bean，但是实际要返回的bean是在配置文件里面配置的，此方法在涉及有些可插拔的功能上，解除程序依赖。parseLookupOverrideSubElements(ele, bd.getMethodOverrides()); 代码如下：

# BeanDefinitionParserDelegate
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);}}
}

//原有的changeMe方法
public class TestChangeMethod {public void changeMe(){System.out.println("ChangeMe");}
}
//新的实现方法
public class ReplacerChangeMethod implements MethodReplacer {@Overridepublic Object reimplement(Object o, Method method, Object[] objects) 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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><bean id="changeMe" class="com.wangjiafu.spring.TestChangeMethod"><replaced-method name="changeMe" replacer="replacer"/></bean><bean id="replacer" class="com.wangjiafu.spring.ReplacerChangeMethod"></bean>
</beans>
//测试方法
public class TestDemo {public static void main(String[] args) {ApplicationContext context = new ClassPathXmlApplicationContext("replaced-method.xml");TestChangeMethod test =(TestChangeMethod) context.getBean("changeMe");test.changeMe();}
}

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

# BeanDefinitionParserDelegate
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);}}
}

我们可以看到无论是 lookup-method 还是 replaced-method 都是构造了 MethodOverride（ReplaceOverride为其实现类） ，并最终记录在了 AbstractBeanDefinition 中的 methodOverrides 属性中。

# BeanDefinitionParserDelegate
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();}}
}

1. 首先提取index、type、name等属性
2. 根据是否配置了index属性解析流程不同
   1. 如果配置了index属性，解析流程如下：
      1. 使用parsePropertyValue(ele, bd, null)方法读取constructor-arg的子元素。
      2. 使用ConstructorArgumentValues.ValueHolder封装解析出来的元素。
      3. 将index、type、name属性也封装进ValueHolder中，然后将ValueHoder添加到当前beanDefinition的ConstructorArgumentValues的indexedArgumentValues，而indexedArgumentValues是一个map类型。
   2. 如果没有配置index属性，将index、type、name属性也封装进ValueHolder中，然后将ValueHoder添加到当前beanDefinition的ConstructorArgumentValues的genericArgumentValues中。

# BeanDefinitionParserDelegate
public 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) {//使用TypedStringValue 来封装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;}
}

1. 首先略过decription和meta属性
2. 提取constructor-arg上的ref和value属性，并验证是否存在
3. 存在ref属性时，用RuntimeBeanReference来封装ref
4. 存在value属性时，用TypedStringValue来封装value
5. 存在子元素时，对于子元素的处理使用了方法parsePropertySubElement(subElement, bd);，其代码如下：

# BeanDefinitionParserDelegate
public Object parsePropertySubElement(Element ele, @Nullable BeanDefinition bd) {return parsePropertySubElement(ele, bd, null);
}
public 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;}
}

# BeanDefinitionParserDelegate
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();}
}

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

public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessorimplements BeanDefinition, Cloneable {// 此处省略静态变量以及final变量@Nullableprivate volatile Object beanClass;/*** bean的作用范围，对应bean属性scope*/@Nullableprivate String scope = SCOPE_DEFAULT;/*** 是否是抽象，对应bean属性abstract*/private boolean abstractFlag = false;/*** 是否延迟加载，对应bean属性lazy-init*/private boolean lazyInit = false;/*** 自动注入模式，对应bean属性autowire*/private int autowireMode = AUTOWIRE_NO;/*** 依赖检查，Spring 3.0后弃用这个属性*/private int dependencyCheck = DEPENDENCY_CHECK_NONE;/*** 用来表示一个bean的实例化依靠另一个bean先实例化，对应bean属性depend-on*/@Nullableprivate String[] dependsOn;/*** autowire-candidate属性设置为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<>(0);@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、replaced-method元素*/@Nullableprivate MethodOverrides methodOverrides;/*** 初始化方法，对应bean属性init-method*/@Nullableprivate String initMethodName;/*** 销毁方法，对应bean属性destroy-method*/@Nullableprivate String destroyMethodName;/*** 是否执行init-method，程序设置*/private boolean enforceInitMethod = true;/*** 是否执行destroy-method，程序设置*/private boolean enforceDestroyMethod = true;/*** 是否是用户定义的而不是应用程序本身定义的，创建AOP时候为true，程序设置*/private boolean synthetic = false;/*** 定义这个bean的应用，APPLICATION：用户，INFRASTRUCTURE：完全内部使用，与用户无关，* SUPPORT：某些复杂配置的一部分* 程序设置*/private int role = BeanDefinition.ROLE_APPLICATION;/*** bean的描述信息*/@Nullableprivate String description;/*** 这个bean定义的资源*/@Nullableprivate Resource resource;
}

<bean id="demo" class="com.wangjiafu.spring.MyTestBean"><property name="beanName" value="bean demo1"/><meta key="demo" value="demo"/><mybean:username="mybean"/></bean>

# BeanDefinitionParserDelegate
public BeanDefinitionHolder decorateBeanDefinitionIfRequired(Element ele, BeanDefinitionHolder definitionHolder) {return decorateBeanDefinitionIfRequired(ele, definitionHolder, null);
}
public BeanDefinitionHolder decorateBeanDefinitionIfRequired(Element ele, BeanDefinitionHolder definitionHolder, @Nullable BeanDefinition containingBd) {BeanDefinitionHolder finalDefinition = definitionHolder;// Decorate based on custom attributes first.NamedNodeMap attributes = ele.getAttributes();for (int i = 0; i < attributes.getLength(); i++) {Node node = attributes.item(i);finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);}// Decorate based on custom nested elements.NodeList children = ele.getChildNodes();for (int i = 0; i < children.getLength(); i++) {Node node = children.item(i);if (node.getNodeType() == Node.ELEMENT_NODE) {finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);}}return finalDefinition;
}

# BeanDefinitionParserDelegate
public BeanDefinitionHolder decorateIfRequired(Node node, BeanDefinitionHolder originalDef, @Nullable BeanDefinition containingBd) {// 获取自定义标签的命名空间String namespaceUri = getNamespaceURI(node);// 过滤掉默认命名标签if (namespaceUri != null && !isDefaultNamespace(namespaceUri)) {// 获取相应的处理器NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);if (handler != null) {// 进行装饰处理BeanDefinitionHolder decorated =handler.decorate(node, originalDef, new ParserContext(this.readerContext, this, containingBd));if (decorated != null) {return decorated;}}else if (namespaceUri.startsWith("http://www.springframework.org/")) {error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", node);}else {if (logger.isDebugEnabled()) {logger.debug("No Spring NamespaceHandler found for XML schema namespace [" + namespaceUri + "]");}}}return originalDef;
}public String getNamespaceURI(Node node) {return node.getNamespaceURI();
}public boolean isDefaultNamespace(@Nullable String namespaceUri) {//BEANS_NAMESPACE_URI = "http://www.springframework.org/schema/beans";return (!StringUtils.hasLength(namespaceUri) || BEANS_NAMESPACE_URI.equals(namespaceUri));
}

# BeanDefinitionReaderUtils
public static void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)throws BeanDefinitionStoreException {// Register bean definition under primary name.//使用beanName做唯一标识注册String beanName = definitionHolder.getBeanName();registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());// Register aliases for bean name, if any.//注册所有的别名String[] aliases = definitionHolder.getAliases();if (aliases != null) {for (String alias : aliases) {registry.registerAlias(beanName, alias);}}
}

# DefaultListableBeanFactory
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)throws BeanDefinitionStoreException {// 校验 beanName 与 beanDefinitionAssert.hasText(beanName, "Bean name must not be empty");Assert.notNull(beanDefinition, "BeanDefinition must not be null");if (beanDefinition instanceof AbstractBeanDefinition) {try {// 校验 BeanDefinition// 这是注册前的最后一次校验了，主要是对属性 methodOverrides 进行校验((AbstractBeanDefinition) beanDefinition).validate();}catch (BeanDefinitionValidationException ex) {throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,"Validation of bean definition failed", ex);}}BeanDefinition oldBeanDefinition;// 从缓存中获取指定 beanName 的 BeanDefinitionoldBeanDefinition = this.beanDefinitionMap.get(beanName);/*** 如果存在*/if (oldBeanDefinition != null) {// 如果存在但是不允许覆盖，抛出异常if (!isAllowBeanDefinitionOverriding()) {throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,"Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +"': There is already [" + oldBeanDefinition + "] bound.");}//else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTUREif (this.logger.isWarnEnabled()) {this.logger.warn("Overriding user-defined bean definition for bean '" + beanName +"' with a framework-generated bean definition: replacing [" +oldBeanDefinition + "] with [" + beanDefinition + "]");}}// 覆盖 beanDefinition 与 被覆盖的 beanDefinition 不是同类else if (!beanDefinition.equals(oldBeanDefinition)) {if (this.logger.isInfoEnabled()) {this.logger.info("Overriding bean definition for bean '" + beanName +"' with a different definition: replacing [" + oldBeanDefinition +"] with [" + beanDefinition + "]");}}else {if (this.logger.isDebugEnabled()) {this.logger.debug("Overriding bean definition for bean '" + beanName +"' with an equivalent definition: replacing [" + oldBeanDefinition +"] with [" + beanDefinition + "]");}}// 允许覆盖，直接覆盖原有的 BeanDefinitionthis.beanDefinitionMap.put(beanName, beanDefinition);}/*** 不存在*/else {// 检测创建 Bean 阶段是否已经开启，如果开启了则需要对 beanDefinitionMap 进行并发控制if (hasBeanCreationStarted()) {// beanDefinitionMap 为全局变量，避免并发情况synchronized (this.beanDefinitionMap) {//this.beanDefinitionMap.put(beanName, beanDefinition);List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);updatedDefinitions.addAll(this.beanDefinitionNames);updatedDefinitions.add(beanName);this.beanDefinitionNames = updatedDefinitions;if (this.manualSingletonNames.contains(beanName)) {Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);updatedSingletons.remove(beanName);this.manualSingletonNames = updatedSingletons;}}}else {// 不会存在并发情况，直接设置this.beanDefinitionMap.put(beanName, beanDefinition);this.beanDefinitionNames.add(beanName);this.manualSingletonNames.remove(beanName);}this.frozenBeanDefinitionNames = null;}if (oldBeanDefinition != null || containsSingleton(beanName)) {// 重新设置 beanName 对应的缓存resetBeanDefinition(beanName);}
}

• 首先 对BeanDefinition 进行校验，该校验也是注册过程中的最后一次校验了，主要是对 AbstractBeanDefinition 的 methodOverrides 属性进行校验。
• 其次根据 beanName 从缓存中获取 BeanDefinition，如果缓存中存在，则根据 allowBeanDefinitionOverriding 标志来判断是否允许覆盖，如果允许则直接覆盖，否则抛出 BeanDefinitionStoreException 异常。
• 若缓存中没有指定 beanName 的 BeanDefinition，则判断当前阶段是否已经开始了 Bean 的创建阶段（），如果是，则需要对 beanDefinitionMap 进行加锁控制并发问题，否则直接设置即可。对于 hasBeanCreationStarted() 方法后续做详细介绍，这里不过多阐述。
• 若缓存中存在该 beanName 或者 单例 bean 集合中存在该 beanName，则调用 resetBeanDefinition() 重置 BeanDefinition 缓存。

# SimpleAliasRegistry
public void registerAlias(String name, String alias) {Assert.hasText(name, "'name' must not be empty");Assert.hasText(alias, "'alias' must not be empty");synchronized (this.aliasMap) {if (alias.equals(name)) {this.aliasMap.remove(alias);}else {String registeredName = this.aliasMap.get(alias);if (registeredName != null) {if (registeredName.equals(name)) {// An existing alias - no need to re-registerreturn;}if (!allowAliasOverriding()) {throw new IllegalStateException("Cannot register alias '" + alias + "' for name '" +name + "': It is already registered for name '" + registeredName + "'.");}}//当A->B存在时，若再次出现A->C->B时候则会抛出异常。checkForAliasCircle(name, alias);this.aliasMap.put(alias, name);}}
}

<bean id="demo" class="com.wangjiafu.spring.MyTestBean" name="demo1,demo2"><property name="beanName" value="bean demo1"/>
</bean>

<bean id="myTestBean" class="com.wangjiafu.spring.MyTestBean"/>
<alias name="myTestBean" alias="testBean1,testBean2"/>

# DefaultBeanDefinitionDocumentReader
protected void processAliasRegistration(Element ele) {//获取beanNameString name = ele.getAttribute(NAME_ATTRIBUTE);//获取aliasString alias = ele.getAttribute(ALIAS_ATTRIBUTE);boolean valid = true;if (!StringUtils.hasText(name)) {getReaderContext().error("Name must not be empty", ele);valid = false;}if (!StringUtils.hasText(alias)) {getReaderContext().error("Alias must not be empty", ele);valid = false;}if (valid) {try {//注册aliasgetReaderContext().getRegistry().registerAlias(name, alias);}catch (Exception ex) {getReaderContext().error("Failed to register alias '" + alias +"' for bean with name '" + name + "'", ele, ex);}getReaderContext().fireAliasRegistered(name, alias, extractSource(ele));}
}

<?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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><bean id="demo" class="com.wangjiafu.spring.MyTestBean" name="demo1,demo2"><property name="beanName" value="bean demo1"/></bean><import resource="lookup-method.xml"/><import resource="replaced-method.xml"/>
</beans>

# DefaultBeanDefinitionDocumentReader.class
protected void importBeanDefinitionResource(Element ele) {// 获取 resource 的属性值 String location = ele.getAttribute(RESOURCE_ATTRIBUTE);// 为空，直接退出if (!StringUtils.hasText(location)) {getReaderContext().error("Resource location must not be empty", ele);return;}// 解析系统属性，格式如 ："${user.dir}"location = getReaderContext().getEnvironment().resolveRequiredPlaceholders(location);Set<Resource> actualResources = new LinkedHashSet<>(4);// 判断 location 是相对路径还是绝对路径boolean absoluteLocation = false;try {absoluteLocation = ResourcePatternUtils.isUrl(location) || ResourceUtils.toURI(location).isAbsolute();}catch (URISyntaxException ex) {// cannot convert to an URI, considering the location relative// unless it is the well-known Spring prefix "classpath*:"}// 绝对路径if (absoluteLocation) {try {// 直接根据地址加载相应的配置文件int importCount = getReaderContext().getReader().loadBeanDefinitions(location, actualResources);if (logger.isDebugEnabled()) {logger.debug("Imported " + importCount + " bean definitions from URL location [" + location + "]");}}catch (BeanDefinitionStoreException ex) {getReaderContext().error("Failed to import bean definitions from URL location [" + location + "]", ele, ex);}}else {// 相对路径则根据相应的地址计算出绝对路径地址try {int importCount;Resource relativeResource = getReaderContext().getResource().createRelative(location);if (relativeResource.exists()) {importCount = getReaderContext().getReader().loadBeanDefinitions(relativeResource);actualResources.add(relativeResource);}else {String baseLocation = getReaderContext().getResource().getURL().toString();importCount = getReaderContext().getReader().loadBeanDefinitions(StringUtils.applyRelativePath(baseLocation, location), actualResources);}if (logger.isDebugEnabled()) {logger.debug("Imported " + importCount + " bean definitions from relative location [" + location + "]");}}catch (IOException ex) {getReaderContext().error("Failed to resolve current resource location", ele, ex);}catch (BeanDefinitionStoreException ex) {getReaderContext().error("Failed to import bean definitions from relative location [" + location + "]",ele, ex);}}// 解析成功后，进行监听器激活处理Resource[] actResArray = actualResources.toArray(new Resource[0]);getReaderContext().fireImportProcessed(location, actResArray, extractSource(ele));
}

1. 获取 source 属性的值，该值表示资源的路径
2. 解析路径中的系统属性，如”${user.dir}”
3. 判断资源路径 location 是绝对路径还是相对路径
   1. 如果是绝对路径，则调递归调用 Bean 的解析过程，进行另一次的解析
   2. 如果是相对路径，则先计算出绝对路径得到 Resource，然后进行解析
4. 通知监听器，完成解析

• 以 classpath*: 或者 classpath: 开头为绝对路径
• 能够通过该 location 构建出 java.net.URL为绝对路径
• 根据 location 构造 java.net.URI 判断调用 isAbsolute() 判断是否为绝对路径

# AbstractBeanDefinitionReader
public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDefinitionStoreException {ResourceLoader resourceLoader = getResourceLoader();if (resourceLoader == null) {throw new BeanDefinitionStoreException("Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");}if (resourceLoader instanceof ResourcePatternResolver) {// Resource pattern matching available.try {Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);int loadCount = loadBeanDefinitions(resources);if (actualResources != null) {for (Resource resource : resources) {actualResources.add(resource);}}if (logger.isDebugEnabled()) {logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]");}return loadCount;}catch (IOException ex) {throw new BeanDefinitionStoreException("Could not resolve bean definition resource pattern [" + location + "]", ex);}}else {// Can only load single resources by absolute URL.Resource resource = resourceLoader.getResource(location);int loadCount = loadBeanDefinitions(resource);if (actualResources != null) {actualResources.add(resource);}if (logger.isDebugEnabled()) {logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");}return loadCount;}
}

1. 获取 source 属性值
2. 得到正确的资源路径
3. 调用 loadBeanDefinitions() 方法进行递归的 BeanDefinition 加载。

<?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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><bean id="demo" class="com.wangjiafu.spring.MyTestBean" name="demo1,demo2"><property name="beanName" value="bean demo1"/></bean><beans></beans>
</beans>

与单独的配置文件并没有太大差别，无非是递归调用beans的解析过程。