1 parseDefaultlement2 bean 标签的解析
2.1 解析 BeanDefinition
2.1.1 对其它属性的解析2.1.2 AbstractBeanDefinition 的属性 2.2 解析默认标签中的自定义标签2.3 注册解析完成的 BeanDefinition
2.3.1 通过 beanName 注册 BeanDefinition2.3.2 alias 的注册 2.4 通知监听器解析注册完成 3 alias 标签的解析4 import 标签的解析5. 嵌入式 beans 标签的解析
1 parseDefaultlementSpring 中的标签包括默认标签和自定义标签。
默认标签的解析在 DefaultBeanDefinitionDucumentReader 中 parseDefaultElement(ele, delegate) 方法中解析。包括 import，alias，bean，beans等标签。
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
// 对 import 标签的解析
if (delegate.nodeNameEquals(ele, import_ELEMENT)) {
importBeanDefinitionResource(ele);
}
// 对 alias 标签的解析
else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
processAliasRegistration(ele);
}
// 对 bean 标签的解析
else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
processBeanDefinition(ele, delegate);
}
// 对 beans 标签的解析
else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
doRegisterBeanDefinitions(ele);
}
}
2 bean 标签的解析
对于四种默认标签的解析，其中 bean 标签的解析最为复杂，因此先对 bean 标签的解析进行分析理解。
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
//1. 委托 BeanDefinitionParserDelegate 类的 parseBeanDefinitionElement 方法进行元素解析，
//返回 BeanDefinitionHolder 的实例 bdHolder，经过该方法，bdHolder实例已经包含配置文件
//中配置的各种属性了，例如class，name，id，alias之类的属性
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if (bdHolder != null) {
//2. 当返回的 bdHolder 不为空的情况下若存在默认标签的子节点下再有自定义属性，还需要
//再次对自定义标签进行解析，装饰者模式,
//在 Spring 中bean 使用的是默认的标签配置，而 子元素又使用了自定义的配置时，会执行该方法
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
// Register the final decorated instance.
//3. 解析完成后，需要对解析后的 bdHolder 进行注册，同样，注册操作委托给 BeanDefinitionReaderUtils
//的 registerBeanDefinition 方法
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
}
catch (BeanDefinitionStoreException ex) {
getReaderContext().error("Failed to register bean definition with name '" +
bdHolder.getBeanName() + "'", ele, ex);
}
// Send registration event.aWW
//发送响应事件，通知相关监听器，这个bean已经加载完成了
//扩展实现，需要对注册 BeanDefinition 时间进行监听时可以通过
//注册监听器的方式将处理逻辑写入监听器. 继承 EmptyReaderEventListener
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
}
上述主要逻辑：
1）委托 BeanDefinitionDelegate 类的 parseBeanDefinitionElement 方法进行元素解析，返回 BeanDefinitionHolder 类型的实例 bdHolder，该实例中已经包含了配置文件的各个属性，如id，class，name，alias 等属性。
2）当返回的 bdHolder 不为空，且该默认标签下的子节点有自定义属性，会调用 delegate 的 decorateBeanDefinitionIfRequired(ele, bdHolder) 方法对 bdHolder 实例进行装饰，将自定义属性包装进该实例中。
3）解析完成后，需要对 bdHolder 进行注册，将该逻辑委托给 BeanDefinitionReaderUtils 工具类的 registerBeanDefinition(bdHolder, registry) 方法。
4）最后发出响应事件，通知相关的监听器，这个 bean 已经加载完成。
首先从元素解析及信息提取开始，就是 BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele)。对 parseBeanDefinitionElement 方法进行分析。
// BeanDefinitionParserDelegate.java
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
return parseBeanDefinitionElement(ele, null);
}
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
//1. 解析元素中的id以及name属性
//解析id属性
String id = ele.getAttribute(ID_ATTRIBUTE);
//解析name属性
String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
//分割name属性，用来为 id 创建一个或多个别名"name1,name2"
List aliases = new ArrayList<>();
if (StringUtils.hasLength(nameAttr)) {
String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
aliases.addAll(Arrays.asList(nameArr));
}
//用 id 作为默认的 beanName
String beanName = id;
if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
//如果id为空，且name不为空，则取name的第一个为id
beanName = aliases.remove(0);
if (logger.isTraceEnabled()) {
logger.trace("No XML 'id' specified - using '" + beanName +
"' as bean name and " + aliases + " as aliases");
}
}
if (containingBean == null) {
//检查beanName的唯一
checkNameUniqueness(beanName, aliases, ele);
}
//2. 最终解析其他属性并统一封装到 GenericBeanDefinition 类型的实例中
AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
if (beanDefinition != null) {
if (!StringUtils.hasText(beanName)) {
try {
//3. 如果不存在beanName 那么根据 Spring 中提供的命名规则为当前bean 生成对应的 beanName
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);
//4. 将获取的信息封装到 BeanDefinitionHolder 的实例中
return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
}
return null;
}
上述代码主要逻辑：
1）提取元素的 id，和 name，name分割作为别，放入名为 alias 的 list 中，将 id 作为默认的 beanName，如果 id 为空且list不为空，取第一个别名作为beanName，并从list中移除。父类 containingBean 为空，检查beanName 的唯一性。
2）调用 parseBeanDefinitionElement(ele, beanName, containingBean) 方法将其它属性一同封装到 GenericBeanDefinition 的 beanDefinition 实例中。
3）返回的 beanDefinition 不为空，检测 beanName 是否有效，如果为空，则调用 Spring 的默认规则为该 bean 生成 beanName。
4）最后将获取到的信息封装到 BeanDefinitionHolder 中并并返回实例。
进一步分析步骤二中对其它属性的解析过程。
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 实例
//用于承载属性的BeanDefinition
AbstractBeanDefinition 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());
//解析 constructor-arg 构造函数子元素
parseConstructorArgElements(ele, bd);
//解析 property 子元素
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;
}
主要解析过程：
1）解析 class(className) 和 parent 属性。
2）使用 className 和 parent 创建用于承载属性的 GenericBeanDefinition 实例。
（1）BeanDefinition 是一个接口，是配置文件中 标签的内部表示，BeanDefinition 和 的属性是一一对应的。
（2）BeanDefinition 的实现由3种: RootBeanDefinition, ChildrenBeanDefinition, GenericBeanDefinition。3中实现都继承自 AbstractBeanDefinition。
（3）Spring 通过 BeanDefinition 将配置文件中的 标签属性转换为容器的内部表示，并将这些 BeanDefinition 注册到 BeanDefinitionRegistry 中。BeanDefinitionRegistry 类似一个配置信息的内存数据库，以 map 形式保存 BeanDefinition 的信息，后序操作直接从 BeanDefinitionRegistry 中读取配置信息。
（4）通过 createBeanDefinition(className, parent) 方法创建 GenericBeanDefinition 属性。
protected AbstractBeanDefinition createBeanDefinition(@Nullable String className, @Nullable String parentName)
throws ClassNotFoundException {
return BeanDefinitionReaderUtils.createBeanDefinition(
parentName, className, this.readerContext.getBeanClassLoader());
}
public static AbstractBeanDefinition createBeanDefinition(
@Nullable String parentName, @Nullable String className, @Nullable ClassLoader classLoader) throws ClassNotFoundException {
//使用GenericBeanDefinition 承载属性
GenericBeanDefinition bd = new GenericBeanDefinition();
bd.setParentName(parentName);
if (className != null) {
//XmlBeanFactory 加载的话 classLoader 为空
if (classLoader != null) {
//如果classLoader不为空，则使用以传入的classLoader 同一虚拟机加载类对象，否则只记录className
bd.setBeanClass(ClassUtils.forName(className, classLoader));
}
else {
bd.setBeanClassName(className);
}
}
return bd;
}
3）解析各种属性并创建完成 GenericBeanDefinition 后，就可以进行 bean 信息的各种属性解析了。由 parseBeanDefinitionAttributes 方法实现。
public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,
@Nullable BeanDefinition containingBean, AbstractBeanDefinition bd) {
// singleton 属性新版本不再有起任何作用, 1.x 的老版本中有使用到, 新版本使用scope 属性
if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {
error("Old 1.x 'singleton' attribute in use - upgrade to 'scope' declaration", ele);
}
//设置scope，singleton 或 property
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.
// 在嵌入beanDefinition 情况下且没有单独指定 scope 属性则使用父类默认的属性
bd.setScope(containingBean.getScope());
}
//解析abstract属性，和 parent 属性联合起来使用，当作一个模板来给子类继承公共属性
if (ele.hasAttribute(ABSTRACT_ATTRIBUTE)) {
//默认为false
bd.setAbstract(TRUE_VALUE.equals(ele.getAttribute(ABSTRACT_ATTRIBUTE)));
}
//解析lazy-init 属性
String lazyInit = ele.getAttribute(LAZY_INIT_ATTRIBUTE);
if (isDefaultValue(lazyInit)) {
lazyInit = this.defaults.getLazyInit();
}
//若没有设置或设置为其它字符都会被设置为false
bd.setLazyInit(TRUE_VALUE.equals(lazyInit));
//解析 autowire 属性，自动注入的方式，该类中如果引用了其它类，会将其它类自动注入
//byName，byType，constructor，default(继承 beans 的 default-autowire属性)，no(默认，不注入)
String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);
bd.setAutowireMode(getAutowireMode(autowire));
//解析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-candidate属性，设为 false 的不会被其它类作为自动注入的候选者，
String autowireCandidate = ele.getAttribute(AUTOWIRE_CANDIDATE_ATTRIBUTE);
//默认值true
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)) {
//默认false
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;
}
4）解析子标签 meta。
public void parsemetaElements(Element ele, BeanmetadataAttributeAccessor attributeAccessor) {
//获取子节点
NodeList nl = ele.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
//提取meta
if (isCandidateElement(node) && nodeNameEquals(node, meta_ELEMENT)) {
Element metaElement = (Element) node;
String key = metaElement.getAttribute(KEY_ATTRIBUTE);
String value = metaElement.getAttribute(VALUE_ATTRIBUTE);
//使用key和value构造 BeanmetadataAttribute
BeanmetadataAttribute attribute = new BeanmetadataAttribute(key, value);
attribute.setSource(extractSource(metaElement));
//记录信息
attributeAccessor.addmetadataAttribute(attribute);
}
}
}
meta 属性的用法，下述代码的 testStr 不会体现在 TestBean 的属性中，而是一个额外的声明，当需要使用这里面的信息时，可以通过 BeanDefinition 的 getAttribute(key) 方法获取。
5）解析子标签 look-method，称为获取器注入，把一个方法声明为返回某种类型的 bean，但实际要返回的 bean 是在配置文件里配置。
应用实例：
public class User {
public void showMe() {
System.out.println("i am user");
}
}
public class Teacher extends User {
@Override
public void showMe() {
System.out.println("i am teacher");
}
}
public class Student extends User {
@Override
public void showMe() {
System.out.println("i am student");
}
}
public abstract class GetBeanTest {
public void showMe() {
this.getBean().showMe();
}
public abstract User getBean();
}
public class Main {
public static void main(String[] args) {
ApplicationContext bf =
new ClassPathXmlApplicationContext("test/lookup/lookupTest.xml");
GetBeanTest getBeanTest = (GetBeanTest) bf.getBean("getBeanTest");
getBeanTest.showMe();
}
}
抽象方法在配置文件中配置，可以替换 lookup-method 标签中 bean 的值来改变具体对应的类。
下面是解析该子标签的逻辑代码：
public void parseLookupOverrideSubElements(Element beanEle, MethodOverrides overrides) {
NodeList nl = beanEle.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
//仅当在Spring默认bean的子元素且为
6）解析子标签 replaced-method 方法级别的替换，可以在运行时用新的方法替换现有的方法。
应用实例
public class TestChangeMethod {
public void changeMe(String text) {
System.out.println(text);
}
}
public class TestMethodReplacer implements MethodReplacer {
@Override
public Object reimplement(Object obj, Method method, Object[] args) throws Throwable {
System.out.println("我替换了原有的方法");
return null;
}
}
public class Main {
public static void main(String[] args) {
ApplicationContext context =
new ClassPathXmlApplicationContext("test/replacedmethod/replacedMethodTest.xml");
TestChangeMethod testChangeMethod = (TestChangeMethod) context.getBean("testChangeMethod");
testChangeMethod.changeMe("你好");
}
}
具体配置文件
解析该子标签的源代码
public void parseReplacedMethodSubElements(Element beanEle, MethodOverrides overrides) {
NodeList nl = beanEle.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
//仅当在 Spring 默认bean 的子元素且为 replaced-method 时
if (isCandidateElement(node) && nodeNameEquals(node, REPLACED_METHOD_ELEMENT)) {
Element replacedMethodEle = (Element) node;
//获取方法名 name (久方法)
String name = replacedMethodEle.getAttribute(NAME_ATTRIBUTE);
//获取替换类的引用 replacer (新方法)
String callback = replacedMethodEle.getAttribute(REPLACER_ATTRIBUTE);
//extends MethodOverride
ReplaceOverride replaceOverride = new ReplaceOverride(name, callback);
// Look for arg-type match elements. 解析子元素 arg-type
//作用是存在 重载方法时，找到具体的方法
List 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-method 一样都是构造成一个 MethodOverride 的实例，并记录到 methodOverrides 中去。
7）解析子标签 constructor-arg，这是对构造函数的解析。
应用实例
public class HelloBean {
private String arg1;
private Integer arg2;
private float arg3;
private Map map;
public HelloBean(String arg1, Integer arg2, float arg3, Map map) {
this.arg1 = arg1;
this.arg2 = arg2;
this.arg3 = arg3;
this.map = map;
}
配置中可以指定参数的索引位置
hello
12
下面是解析该子标签的逻辑代码：
public void parseConstructorArgElements(Element beanEle, BeanDefinition bd) {
NodeList nl = beanEle.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
//是 Spring 默认标签下 constructor-arg 的子元素
if (isCandidateElement(node) && nodeNameEquals(node, CONSTRUCTOR_ARG_ELEMENT)) {
//调用该方法解析每一个构造器子元素
parseConstructorArgElement((Element) node, bd);
}
}
}
具体的解析由parseConstructorArgElement((Element) node, bd)方法实现。
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);
//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));
//解析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());
// 解析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));
bd.getConstructorArgumentValues().addGenericArgumentValue(valueHolder);
}
finally {
this.parseState.pop();
}
}
}
主要解析步骤，提取 index, type, name 属性。
如果指定了index属性：
解析 Constructor-arg 的子元素使用 ConstructorArgumentValues.ValueHolder 封装解析出的元素将 index, type, name属性 一并封装到 ConstructorArgumentValues.ValueHolder 类型中，并添加至 BeanDefinition 的 constructorArgumentValues 的 indexArgumentValues 中
如果没有index属性：解析 Constructor-arg 的子元素使用 ConstructorArgumentValues.ValueHolder 封装解析出的元素将 index, type, name属性 一并封装到 ConstructorArgumentValues.ValueHolder 类型中，并添加至 BeanDefinition 的 constructorArgumentValues 的 genericArgumentValues 中
对于 属性及子标签的解析由 parsePropertyValue方法实现：
@Nullable
public Object parsePropertyValue(Element ele, BeanDefinition bd, @Nullable String propertyName) {
//元素的类型 property 或 constructor-arg
String elementName = (propertyName != null ?
" element for property '" + propertyName + "'" :
" 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;
}
}
}
//解析 constructor-arg 上的 ref 属性
boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE);
//解析 constructor-arg 上的 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) {
//ref 属性的处理
String refName = ele.getAttribute(REF_ATTRIBUTE);
if (!StringUtils.hasText(refName)) {
error(elementName + " contains empty 'ref' attribute", ele);
}
//封装到 RuntimeDeanDefinition 中
RuntimeBeanReference ref = new RuntimeBeanReference(refName);
ref.setSource(extractSource(ele));
return ref;
}
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 {
// Neither child element nor "ref" or "value" attribute found.
error(elementName + " must specify a ref or value", ele);
return null;
}
}
从上述代码可以看出对 标签元素的解析主要有下面几个步骤：
略过 description 或 meta获取 constructor-arg 上的 ref 和 value 属性，其不存在以下情况
既有 ref 属性又有 value 属性存在 ref(value) 属性又有 ref(value) 子元素
ref 属性的处理，使用 RuntimeDeanDefinition 封装，如 value 属性的处理，使用 TypedStringValue 封装，如 对子元素的处理，调用 parsePropertySubElement 方法对各种子元素进行处理
而对于子标签的处理，例如在构造函数中嵌入了
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;
}
//ref 标签
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 element", ele);
return null;
}
}
if (!StringUtils.hasText(refName)) {
error(" 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;
}
}
可以看到上面所有支持的子标签包括：
beanrefidrefvaluenullarraylistsetmapprops
8）解析子标签 property
parsePropertyElements 方法完成了对 property 子标签的解析，使用方法如下。
具体解析过程：
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);
}
}
}
上述代码的逻辑是提取所有 子标签，并调用parsePropertyElement((Element) node, bd)方法解析。
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;
}
//解析ele对应的属性元素 和 constructor-arg 调用的同一个方法
Object val = parsePropertyValue(ele, bd, propertyName);
//使用 PropertyValue 封装
PropertyValue pv = new PropertyValue(propertyName, val);
parsemetaElements(ele, pv);
pv.setSource(extractSource(ele));
// 存到 propertyValues
bd.getPropertyValues().addPropertyValue(pv);
}
finally {
this.parseState.pop();
}
}
可以看到和解析 constructor-arg 一样都是调用 parsePropertyValue 来解析值。不同的是使用 PropertyValue 进行封装，并存放到 propertyValues 属性中。
9）解析子标签 qualifier
Spring 许我 Qualifier 指定注入 Bean 名称，而对于配置方式使用如下。
主要逻辑：
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);
}
}
}
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));
//bean 名称
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);
//解析 attribute 子元素，额外数据，类似 bean 的 子元素 meta
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;
}
}
}
//加到 qualifiers 中
bd.addQualifier(qualifier);
}
finally {
this.parseState.pop();
}
}
2.1.2 AbstractBeanDefinition 的属性
到此完成了从 XML 配置文件到 GenericBeanDefinition 的转换，XML 中的所有属性都可以在 GenericBeanDefinition 中找到。而 GenericBeanDefinition 是子类实现，其主要属性都在 AbstractBeanDefinition 中。
public abstract class AbstractBeanDefinition extends BeanmetadataAttributeAccessor
implements BeanDefinition, Cloneable {
@Nullable
private volatile Object beanClass;
@Nullable
private String scope = SCOPE_DEFAULT;
private boolean abstractFlag = false;
private boolean lazyInit = false;
private int autowireMode = AUTOWIRE_NO;
private int dependencyCheck = DEPENDENCY_CHECK_NONE;
@Nullable
private String[] dependsOn;
private boolean autowireCandidate = true;
private boolean primary = false;
private final Map qualifiers = new linkedHashMap<>();
@Nullable
private Supplier instanceSupplier;
private boolean nonPublicAccessAllowed = true;
private boolean lenientConstructorResolution = true;
@Nullable
private String factoryBeanName;
@Nullable
private String factoryMethodName;
@Nullable
private ConstructorArgumentValues constructorArgumentValues;
@Nullable
private MutablePropertyValues propertyValues;
private MethodOverrides methodOverrides = new MethodOverrides();
@Nullable
private String initMethodName;
@Nullable
private String destroyMethodName;
private boolean enforceInitMethod = true;
private boolean enforceDestroyMethod = true;
private boolean synthetic = false;
private int role = BeanDefinition.ROLE_APPLICATION;
@Nullable
private String description;
@Nullable
private Resource resource;
...
}
2.2 解析默认标签中的自定义标签
完成了默认标签的解析和提取后（BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);），解析来就是bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);的分析。这句代码是在默认 标签下有自定义子标签的情况下处理的，如：
具体逻辑：
// BeanDefinitionParserDelegate.java
public BeanDefinitionHolder decorateBeanDefinitionIfRequired(Element ele, BeanDefinitionHolder originalDef) {
// 参数3 传的是父类 bean，当对某个嵌套配置进行分析 ，这里需要传递父类
// beanDefinition 这里传递的参数是为了使用父类的 scope 属性，以备子类若
// 没有设置 scope 默认使用父类的属性，这里是顶层配置所以是 null。
return decorateBeanDefinitionIfRequired(ele, originalDef, null);
}
进一步跟踪：
public BeanDefinitionHolder decorateBeanDefinitionIfRequired(
Element ele, BeanDefinitionHolder originalDef, @Nullable BeanDefinition containingBd) {
BeanDefinitionHolder finalDefinition = originalDef;
// 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;
}
上述代码可以看出对所有的属性及子节点调用了 decorateIfRequired 方法。
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 {
// A custom namespace, not to be handled by Spring - maybe "xml:...".
if (logger.isDebugEnabled()) {
logger.debug("No Spring NamespaceHandler found for XML schema namespace [" + namespaceUri + "]");
}
}
}
return originalDef;
}
上述代码的主要逻辑：
获取命名空间判断该元素或属性是否符合自定义的标签的解析条件找到对应 NamespaceHandler 进行解析
2.3 注册解析完成的 BeanDefinition
完成配置文件的解析及装饰后，就可以进行注册了。即调用 BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry()) 方法进行注册。
public static void registerBeanDefinition(
BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
throws BeanDefinitionStoreException {
// Register bean definition under primary name.
String beanName = definitionHolder.getBeanName();
// 使用注册器 进行注册 DefaultListableBeanFactory
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
//注册别名 SimpleAliasRegistry
// Register aliases for bean name, if any.
String[] aliases = definitionHolder.getAliases();
if (aliases != null) {
for (String alias : aliases) {
registry.registerAlias(beanName, alias);
}
}
}
解析后的 BeanDefinition 会被注册到 BeanDefinitionRegistry 类型的实例 registry 中，主要包括 beanName 的注册和 aliases 的注册。
2.3.1 通过 beanName 注册 BeanDefinition
调用 DefaultListableBeanDeanFactory#registerBeanDefinition 方法。
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException {
Assert.hasText(beanName, "Bean name must not be empty");
Assert.notNull(beanDefinition, "BeanDefinition must not be null");
if (beanDefinition instanceof AbstractBeanDefinition) {
try {
((AbstractBeanDefinition) beanDefinition).validate();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
"Validation of bean definition failed", ex);
}
}
// 使用 ConcurrentHashMap 来进行并发的控制
BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
//存在已注册的名字
if (existingDefinition != null) {
//如果对于的 beanName 已被注册，且在配置中配置了bean 不允许覆盖，则抛出异常
if (!isAllowBeanDefinitionOverriding()) {
throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
}
// 判断 Bean 的角色大小:
// 0：用户定义的 Bean、1：来源于配置文件的 Bean、2：Spring 内部的 Bean；
// 当原 BeanDefinition 角色小于新的 BeanDefinition 角色时，输出一个 warn 日志，提示 BeanDefinition 被覆盖
else if (existingDefinition.getRole() < beanDefinition.getRole()) {
// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
if (logger.isInfoEnabled()) {
logger.info("Overriding user-defined bean definition for bean '" + beanName +
"' with a framework-generated bean definition: replacing [" +
existingDefinition + "] with [" + beanDefinition + "]");
}
}
else if (!beanDefinition.equals(existingDefinition)) {
if (logger.isDebugEnabled()) {
logger.debug("Overriding bean definition for bean '" + beanName +
"' with a different definition: replacing [" + existingDefinition +
"] with [" + beanDefinition + "]");
}
}
else {
if (logger.isTraceEnabled()) {
logger.trace("Overriding bean definition for bean '" + beanName +
"' with an equivalent definition: replacing [" + existingDefinition +
"] with [" + beanDefinition + "]");
}
}
//放入缓存中，替换原有的
this.beanDefinitionMap.put(beanName, beanDefinition);
}
else {
//是否 bean 的创建已经开始
if (hasBeanCreationStarted()) {
// Cannot modify startup-time collection elements anymore (for stable iteration)
//不能修改原有的 beanDefinitionNames 集合
synchronized (this.beanDefinitionMap) {
this.beanDefinitionMap.put(beanName, beanDefinition);
// 创建新的 beanNames 集合，并将已缓存的 beanName 和新的 beanName 加入该集合
List updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
updatedDefinitions.addAll(this.beanDefinitionNames);
updatedDefinitions.add(beanName);
this.beanDefinitionNames = updatedDefinitions;
// 在手动注册 Bean 的集合中，如果存在同名的 beanName，则将集合中同名的 beanName 删除
removeManualSingletonName(beanName);
}
}
//还在注册阶段
else {
// Still in startup registration phase
//注册
this.beanDefinitionMap.put(beanName, beanDefinition);
//记录beanName
this.beanDefinitionNames.add(beanName);
// 删除手动注册 Bean 集合中同名的 beanName
removeManualSingletonName(beanName);
}
// 将存储冻结 BeanDefinition 的 Map 置为 null
this.frozenBeanDefinitionNames = null;
}
// 当前注册的 BeanDefinition 已在 beanDefinitionMap 中存在，或者其实例已在存储单例 Bean 的 Map 中存在
if (existingDefinition != null || containsSingleton(beanName)) {
//重置所有缓存
resetBeanDefinition(beanName);
}
}
主要步骤如下：
对 AbstractBeanDefinition 的校验。针对 methodOverrides 属性的校验。对 beanNam 已经存在的情况进行处理，如果设置了不允许 bean 的覆盖，则抛出异常。加入 map 缓存。清除解析之前留下的对应 beanName 缓存。
2.3.2 alias 的注册
调用 SimpleAliasRegistry#registerAlias 方法进行注册。
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) {
// 如果 beanName 和 alias 相同则不记录 alias，并且删除 alias
if (alias.equals(name)) {
this.aliasMap.remove(alias);
if (logger.isDebugEnabled()) {
logger.debug("Alias definition '" + alias + "' ignored since it points to same name");
}
}
else {
String registeredName = this.aliasMap.get(alias);
//已存在指向
if (registeredName != null) {
//如果相同则不执行
if (registeredName.equals(name)) {
// An existing alias - no need to re-register
return;
}
//如不允许被覆盖，则抛出异常
if (!allowAliasOverriding()) {
throw new IllegalStateException("Cannot define alias '" + alias + "' for name '" +
name + "': It is already registered for name '" + registeredName + "'.");
}
//打印日志
if (logger.isDebugEnabled()) {
logger.debug("Overriding alias '" + alias + "' definition for registered name '" +
registeredName + "' with new target name '" + name + "'");
}
}
//循环检查
//如 A -> B,且 A -> C -> B ，则抛出异常
checkForAliasCircle(name, alias);
//注册alias
this.aliasMap.put(alias, name);
if (logger.isTraceEnabled()) {
//打印
logger.trace("Alias definition '" + alias + "' registered for name '" + name + "'");
}
}
}
}
主要解析步骤：
alias 与 beanName 相同的处理。如果 beanName 和 alias 相同则不记录 alias，并且删除 aliasalias 覆盖处理。根据用户的设置进行处理。alias 的循环检测。注册alias。
2.4 通知监听器解析注册完成
通过代码getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));完成此工作，这里的实现只为扩展，当程序开发人员需要对注册 BeanDefinition 事件进行监听时可以通过注册监听器的方式并将处理逻辑写入监听器中，目前在 Spring 中并没有对此事件做任何逻辑处理。
3 alias 标签的解析
在对 bean 进行定义时，除了使用 id 属性来指定名称之外，为了提供多个名称，可以使用 alias 标签来指定。而所有的这些名称都指向同一个 bean ，在某些情况下提供别名非常有用，比如为了让应用的每个组件能更容易地对公共组件进行引用。
在 XML 配置文件中使用 标签完成 bean 别名的定义，如下。
具体解析过程如下：
protected void processAliasRegistration(Element ele) {
// 获取 beanName
String name = ele.getAttribute(NAME_ATTRIBUTE);
// 获取 alias
String 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 {
// 注册 alias，和 bean 中 alias 的注册一样
getReaderContext().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));
}
}
4 import 标签的解析
标签可以用来作分模块处理。如下：
具体解析逻辑：
protected void importBeanDefinitionResource(Element ele) {
//获取resource属性
String location = ele.getAttribute(RESOURCE_ATTRIBUTE);
// 不存在 resource 属性，不做处理
if (!StringUtils.hasText(location)) {
getReaderContext().error("Resource location must not be empty", ele);
return;
}
// 解析系统属性，格式如 "${user.dir}"
// Resolve system properties: e.g. "${user.dir}"
location = getReaderContext().getEnvironment().resolveRequiredPlaceholders(location);
Set actualResources = new linkedHashSet<>(4);
// Discover whether the location is an absolute or relative URI
//判断 location 是相对 URI 还是绝对 URI
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*:"
}
// Absolute or relative?
if (absoluteLocation) {
try {
// 如果是绝对路径，直接根据地址加载对应的配置文件
int importCount = getReaderContext().getReader().loadBeanDefinitions(location, actualResources);
if (logger.isTraceEnabled()) {
logger.trace("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 {
// No URL -> considering resource location as relative to the current file.
//计算出绝对路径
try {
int importCount;
//Resource 存在多个实现子类，每个实现类的 createRelative 不同
//先使用子类的方法进行解析
Resource relativeResource = getReaderContext().getResource().createRelative(location);
if (relativeResource.exists()) {
importCount = getReaderContext().getReader().loadBeanDefinitions(relativeResource);
actualResources.add(relativeResource);
}
else {
//解析不成功，则使用 ResourcePatternResolver 进行解析
String baseLocation = getReaderContext().getResource().getURL().toString();
importCount = getReaderContext().getReader().loadBeanDefinitions(
StringUtils.applyRelativePath(baseLocation, location), actualResources);
}
if (logger.isTraceEnabled()) {
logger.trace("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));
}
主要逻辑如下：
获取resource属性解析系统属性，格式如 “${user.dir}”判断 location 是相对 URI 还是绝对 URI如果是绝对路径则递归调用 bean 的解析过程，进行另一次的解析如果相对路径则计算出绝对路径进行解析通知监听器，解析完成
5. 嵌入式 beans 标签的解析
...
对 标签的解析就是递归调用 DefaultBeanDefinitiondocumentReader#doRegisterBeanDefinitions 方法进行解析。
