湛江的网站,seo是什么意思网络用语,动漫设计难不难学,php和ASP网站那个好三、默认标签的解析 Spring的标签中有 默认标签和 自定义标签#xff0c;两者的解析有着很大的不同#xff0c;这次重点说默认标签的解析过程。 DefaultBeanDefinitionDocumentReader.class 默认标签的解析是在 DefaultBeanDefinitionDocumentReader.parseDefaultElement()函…三、默认标签的解析
Spring的标签中有 默认标签和 自定义标签两者的解析有着很大的不同这次重点说默认标签的解析过程。 DefaultBeanDefinitionDocumentReader.class 默认标签的解析是在 DefaultBeanDefinitionDocumentReader.parseDefaultElement()函数中进行的分别对4种不同的标签 import, alias, bean和 beans做了不同处理。我们先看下此函数的源码 # 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);}
} 3.1 Bean标签的解析及注册
在4种标签中对bean标签的解析最为复杂也最为重要所以从此标签开始深入分析如果能理解这个标签的解析过程其他标签的解析就迎刃而解了。对于bean标签的解析用的是 DefaultBeanDefinitionDocumentReader # processBeanDefinition(ele,delegate)方法首先看看函数processBeanDefinition(ele,delegate)其代码如下 # 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实例已经包含了我们配置文件中的各种属性了例如classnameidalias等。当返回的bdHolder不为空的情况下若存在默认标签的子节点下再有自定义属性还需要再次对自定义标签进行解析。当解析完成后需要对解析后的bdHolder进行注册注册过程委托给了BeanDefinitionReaderUtils的registerBeanDefinition方法。最后发出响应事件通知相关的监听器已经加载完这个Bean了。 时序图如下 3.1.1 解析BeanDefinition DefaultBeanDefinitionDocumentReader .class 接下来我们就针对具体的方法进行分析首先我们从元素解析及信息提取开始也就是BeanDefinitionHolder bdHolder delegate.parseBeanDefinitionElementele进入 BeanDefinitionParserDelegate 类的 parseBeanDefinitionElement() 方法。 我们看下源码 # BeanDefinitionParserDelegate
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, Nullable BeanDefinition containingBean) {// 解析 ID 属性String id ele.getAttribute(ID_ATTRIBUTE);// 解析 name 属性String nameAttr ele.getAttribute(NAME_ATTRIBUTE);// 分割 name 属性ListString 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;
} 上述方法就是对 默认标签解析的全过程了我们分析下当前层完成的工作 提取元素中的id和name属性进一步解析其他所有属性并统一封装到GenericBeanDefinition类型的实例中如果检测到bean没有指定beanName那么使用默认规则为此bean生成beanName。将获取到的信息封装到BeanDefinitionHolder的实例中。 我们进一步查看步骤2中对标签其他属性的解析过程代码 AbstractBeanDefinition beanDefinition parseBeanDefinitionElement(ele, beanName, containingBean); 是用来对标签中的其他属性进行解析我们详细看下源码 # 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;
} 3.1.1.1 创建用于承载属性的BeanDefinition BeanDefinitionParserDelegate.class BeanDefinition是一个接口在spring中此接口有三种实现 RootBeanDefinition、 ChildBeanDefinition以及 GenericBeanDefinition。而三种实现都继承了 AbstractBeanDefinition其中BeanDefinition是配置文件元素标签在容器中的内部表示形式。元素标签拥有class、scope、lazy-init等属性BeanDefinition则提供了相应的beanClass、scope、lazyInit属性 BeanDefinition和中的属性一一对应。其中 RootBeanDefinition是最常用的实现类他对应一般性的元素标签 GenericBeanDefinition是自2.5版本以后新加入的bean文件配置属性定义类是一站式服务的。 在 配置文件中可以定义父和子父用RootBeanDefinition表示而子用ChildBeanDefinition表示而 没有父的就使用RootBeanDefinition表示。AbstractBeanDefinition对两者共同的类信息进行抽象。 Spring 通过BeanDefinition将配置文件中的配置信息转换为容器的内部表示并 将这些BeanDefinition注册到BeanDefinitionRegistry中。Spring容器的 BeanDefinitionRegistry就像是Spring配置信息的内存数据库主要是以 map的形式保存后续操作直接从BeanDefinitionResistry中读取配置信息。它们之间的关系如下图所示 因此要解析属性首先要创建用于承载属性的实例也就是创建 GenericBeanDefinition类型的实例。而代码 createBeanDefinition(className,parent)的作用就是实现此功能。我们详细看下方法体代码如下 # 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;
} 3.1.1.2 解析各种属性 BeanDefinitionParserDelegate.class 当创建好了承载bean信息的实例后接下来就是解析各种属性了首先我们看下 parseBeanDefinitionAttributes(ele, beanName, containingBean, 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;
} 3.1.1.3 解析子元素meta BeanDefinitionParserDelegate.class 在开始对meta元素解析分析前我们先简单回顾下meta属性的使用简单的示例代码如下 bean iddemo classcom.yhl.myspring.demo.bean.MyBeanDemoproperty namebeanName valuebean demo1/meta keydemo valuedemo/
/bean
这段代码并不会提现在demo的属性中而是一个额外的声明如果需要用到这里面的信息时可以通过 BeanDefinition的 getAttribute(key)方法获取对meta属性的解析用的是 parseMetaElements(ele, 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);}}
} 3.1.1.4 解析子元素lookup-method
这个方法主要是针对bean中lookup-method子元素的提取。 BeanDefinitionParserDelegate.class //testLookUp.xml
bean idgetBeanTest classcom.xxx.lookupmethod.GetBeanTest lookup-method beanKobe namegetPlayer/ /bean
bean idKobe classcom.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);}}
} 3.1.1.5 解析子元素replaced-method
这个方法主要是针对bean中replaced-method子元素的提取。 BeanDefinitionParserDelegate.class 方法替换可以在运行时用新的方法替换现有的方法与之前look-up不同的是replace-method不但可以动态的替换返回实体bean而且还能动态的更改原有方法的逻辑我们看下使用 //原有的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 version1.0 encodingUTF-8 ?
beans xmlnshttp://www.springframework.org/schema/beansxmlns:xsihttp://www.w3.org/2001/XMLSchema-instancexsi:schemaLocationhttp://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdbean idchangeMe classcom.wangjiafu.spring.TestChangeMethodreplaced-method namechangeMe replacerreplacer//beanbean idreplacer classcom.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.ListElement 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 都是构造了 MethodOverrideReplaceOverride为其实现类 并最终记录在了 AbstractBeanDefinition 中的 methodOverrides 属性中。 3.1.1.6 解析子元素constructor-arg BeanDefinitionParserDelegate.class 对于 construtor-arg子元素的解析Spring通过 parseConstructorArgElements方法来实现的代码如下 # 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();}}
} 上述代码的流程可以简单的总结为如下 首先提取index、type、name等属性根据是否配置了index属性解析流程不同 如果配置了index属性解析流程如下 使用parsePropertyValue(ele, bd, null)方法读取constructor-arg的子元素。使用ConstructorArgumentValues.ValueHolder封装解析出来的元素。将index、type、name属性也封装进ValueHolder中然后将ValueHoder添加到当前beanDefinition的ConstructorArgumentValues的indexedArgumentValues而indexedArgumentValues是一个map类型。 如果没有配置index属性将index、type、name属性也封装进ValueHolder中然后将ValueHoder添加到当前beanDefinition的ConstructorArgumentValues的genericArgumentValues中。 进一步了解解析构造函数配置中子元素的过程进入 parsePropertyValue(ele, bd, null); 代码如下 # 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 were 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;}
} 上述代码的执行逻辑简单总结为 首先略过decription和meta属性提取constructor-arg上的ref和value属性并验证是否存在存在ref属性时用RuntimeBeanReference来封装ref存在value属性时用TypedStringValue来封装value存在子元素时对于子元素的处理使用了方法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)) {// Its a distinguished null value. Lets 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;}
} 3.1.1.7 解析子元素property BeanDefinitionParserDelegate.class parsePropertyElement函数完成了对property属性的提取对于propertie元素的解析是使用的 parsePropertyElements(ele, bd);方法我们看下其源码如下 # 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);}}
} 里面实际的解析是用的 parsePropertyElement((Element) node, bd);方法继续跟踪代码 public void parsePropertyElement(Element ele, BeanDefinition bd) {String propertyName ele.getAttribute(NAME_ATTRIBUTE);if (!StringUtils.hasLength(propertyName)) {error(Tag property must have a name attribute, ele);return;}this.parseState.push(new PropertyEntry(propertyName));try {//不允许多次对同一属性配置if (bd.getPropertyValues().contains(propertyName)) {error(Multiple property definitions for property propertyName , ele);return;}Object val parsePropertyValue(ele, bd, propertyName);PropertyValue pv new PropertyValue(propertyName, val);parseMetaElements(ele, pv);pv.setSource(extractSource(ele));bd.getPropertyValues().addPropertyValue(pv);}finally {this.parseState.pop();}
} 我们看到代码的逻辑非常简单 在获取了propertie的属性后使用PropertyValue 进行封装然后将其添加到BeanDefinition的propertyValueList中。 3.1.1.8 解析子元素qualifier BeanDefinitionParserDelegate.class 对于qualifier元素的获取接触更多的是注解的形式在使用Spring框架中进行自动注入时Spring容器中 匹配的候选Bean数目必须有且仅有一个当找找不到一个匹配的Bean时Spring容器将会抛出BeanCreationException异常并指出必须至少拥有一个匹配的Bean。 Spring 允许我们通过Qualifier 指定注入 Bean的名称这样歧义就消除了而对于配置方式使用如 bean idmyTestBean classcom.wangjiafu.spring.MyTestBeanqualifier typeorg.Springframework.beans.factory.annotation.Qualifier valuegf /
/bean 其解析过程与之前大同小异 这里不再重复叙述。 3.1.2 AbstractBeanDefinition 属性
至此我们便完成了对 XML 文档到 GenericBeanDefinition 的转换 就是说到这里 XML 中所有的配置都可以在 GenericBeanDefinition的实例类中应找到对应的配置。 GenericBeanDefinition 只是子类实现而大部分的通用属性都保存在了 AbstractBeanDefinition 中那么我们再次通过 AbstractBeanDefinition 的属性来回顾一 下我们都解析了哪些对应的配置。 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 MapString, 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;
} 3.1.3 默认标签中的自定义标签解析
之前我们已经分析了对于默认标签的解析我们再次回顾下默认标签解析函数的起始函数如下图片中有一个方法 delegate.decorateBeanDefinitionIfRequired(ele, bdHolder) DefaultBeanDefinitionDocumentReader.class 这个方法的作用是什么呢首先我们看下这种场景如下配置文件 bean iddemo classcom.wangjiafu.spring.MyTestBeanproperty namebeanName valuebean demo1/meta keydemo valuedemo/mybean:usernamemybean//bean 这个配置文件中有个 自定义的标签 decorateBeanDefinitionIfRequired方法就是用来处理这种情况的其中的null是用来传递父级BeanDefinition的我们进入到其方法体 # 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;
} 我们看到上面的代码有两个遍历操作一个是用于对 所有的属性进行遍历处理另一个是 对所有的子节点进行遍历处理两个遍历操作都用到了 decorateIfRequired(node, finalDefinition, containingBd);方法我们继续跟踪代码进入方法体 # 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));
} 首先获取自定义标签的命名空间如果不是默认的命名空间则根据该命名空间获取相应的处理器最后调用处理器的 decorate() 进行装饰处理。具体的装饰过程这里不进行讲述在后面分析自定义标签时会做详细说明。 3.1.4 注册解析的BeanDefinition DefaultBeanDefinitionDocumentReader.class 对于配置文件解析和装饰完成之后对于得到的beanDefinition已经可以满足后续的使用要求了还剩下注册也就是 DefaultBeanDefinitionDocumentReader #processBeanDefinition() 函数中的 BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder,getReaderContext().getRegistry()) 代码的解析了。 进入方法体 # 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);}}
} 从上面的代码我们看到是用了beanName作为唯一标示进行注册的然后注册了所有的别名aliase。而beanDefinition最终都是注册到BeanDefinitionRegistry中接下来我们具体看下注册流程。 3.1.4.1 通过beanName注册BeanDefinition BeanDefinitionReaderUtils.class 在spring中除了 使用beanName作为key将BeanDefinition放入Map中还做了其他一些事情我们看下方法registerBeanDefinition代码BeanDefinitionRegistry是一个接口他有三个实现类DefaultListableBeanFactory、SimpleBeanDefinitionRegistry、GenericApplicationContext其中SimpleBeanDefinitionRegistry非常简单而GenericApplicationContext最终也是使用的DefaultListableBeanFactory中的实现方法我们看下代码 # 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);ListString updatedDefinitions new ArrayList(this.beanDefinitionNames.size() 1);updatedDefinitions.addAll(this.beanDefinitionNames);updatedDefinitions.add(beanName);this.beanDefinitionNames updatedDefinitions;if (this.manualSingletonNames.contains(beanName)) {SetString 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 缓存。 其实整段代码的核心就在于 this.beanDefinitionMap.put(beanName, beanDefinition); 。BeanDefinition 的缓存也不是神奇的东西就是 定义一个 ConcurrentHashMapkey 为 beanNamevalue 为 BeanDefinition。 3.1.4.2 通过别名注册BeanDefinition BeanDefinitionReaderUtils.class 通过别名注册BeanDefinition最终是在SimpleAliasRegistry中实现的我们看下代码 # 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);}}
} 上述代码的流程总结如下 1 alias与beanName相同情况处理若alias与beanName名称相同则不需要处理并删除原有的alias 2 alias覆盖处理。若aliasName已经使用并已经指向了另一beanName则需要用户的设置进行处理 3 alias循环检查当A-B存在时若再次出现A-C-B时候则会抛出异常。 3.1.5 通知监听器解析及注册完成_可扩展 DefaultBeanDefinitionDocumentReader.class 通过getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder)); 代码完成此工作这里的实现只为扩展目前Spring中并没有对此事件做任何逻辑处理。当程序开发人员需要对注册BeanDefinition事件进行监听时可以通过 注册监听器的方式并将处理逻辑写入监听器当中。 3.2 alisa标签的解析
对应bean标签的解析是最核心的功能对于alias、import、beans标签的解析都是基于bean标签解析的接下来我就分析下alias标签的解析。我们回到 parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate)方法继续看下方法体如下图所示 DefaultBeanDefinitionDocumentReader.class 对bean进行定义时除了用id来 指定名称外 为了提供多个名称可以使用alias标签来指定而所有这些名称都指向同一个bean。在XML配置文件中可用单独的元素来完成bean别名的定义。我们可以直接使用bean标签中的name属性如下 bean iddemo classcom.wangjiafu.spring.MyTestBean namedemo1,demo2property namebeanName valuebean demo1/
/bean 在Spring还有另外一种声明别名的方式 bean idmyTestBean classcom.wangjiafu.spring.MyTestBean/
alias namemyTestBean aliastestBean1,testBean2/ 我们具体看下alias标签的解析过程解析使用的方法processAliasRegistration(ele)方法体如下 # 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));}
} 通过代码可以发现解析流程与bean中的alias解析大同小异都是将 beanName与别名alias组成一对注册到registry中。跟踪代码最终使用了 SimpleAliasRegistry中的 registerAlias(String name, String alias)方法。 3.3 import标签的解析 DefaultBeanDefinitionDocumentReader.class 对于Spring配置文件的编写经历过大型项目的人都知道里面有太多的配置文件了。基本采用的方式都是分模块分模块的方式很多使用import就是其中一种例如我们可以构造这样的Spring配置文件 ?xml version1.0 encodingUTF-8 ?
beans xmlnshttp://www.springframework.org/schema/beansxmlns:xsihttp://www.w3.org/2001/XMLSchema-instancexsi:schemaLocationhttp://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdbean iddemo classcom.wangjiafu.spring.MyTestBean namedemo1,demo2property namebeanName valuebean demo1//beanimport resourcelookup-method.xml/import resourcereplaced-method.xml/
/beans applicationContext.xml文件中 使用import方式导入有模块配置文件以后若有新模块的加入那就可以简单修改这个文件了。这样大大简化了配置后期维护的复杂度并使配置模块化易于管理。我们来看看Spring是如何解析import配置文件的呢。解析import标签使用的是 importBeanDefinitionResource(ele)进入方法体 # 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);SetResource 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));
} 解析 import 过程较为清晰整个过程如下 获取 source 属性的值该值表示资源的路径解析路径中的系统属性如”${user.dir}”判断资源路径 location 是绝对路径还是相对路径 如果是绝对路径则调递归调用 Bean 的解析过程进行另一次的解析如果是相对路径则先计算出绝对路径得到 Resource然后进行解析 通知监听器完成解析 判断路径 方法通过以下方法来判断 location 是为相对路径还是绝对路径 DefaultBeanDefinitionDocumentReader.class 判断绝对路径的规则如下 以 classpath*: 或者 classpath: 开头为绝对路径能够通过该 location 构建出 java.net.URL为绝对路径根据 location 构造 java.net.URI 判断调用 isAbsolute() 判断是否为绝对路径 如果 location 为绝对路径则调用 loadBeanDefinitions()该方法在 AbstractBeanDefinitionReader 中定义代码如下 # AbstractBeanDefinitionReader
public int loadBeanDefinitions(String location, Nullable SetResource 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;}
} 整个逻辑比较简单首先获取 ResourceLoader然后根据不同的 ResourceLoader 执行不同的逻辑主要是可能存在多个 Resource但是最终都会回归到 XmlBeanDefinitionReader.loadBeanDefinitions() 所以这是一个 递归的过程。 至此import 标签解析完毕整个过程比较清晰明了 获取 source 属性值得到正确的资源路径调用 loadBeanDefinitions() 方法进行递归的 BeanDefinition 加载。 3.4 嵌入式beans标签的解析 DefaultBeanDefinitionDocumentReader.class 类似import标签所提供的功能如下 ?xml version1.0 encodingUTF-8 ?
beans xmlnshttp://www.springframework.org/schema/beansxmlns:xsihttp://www.w3.org/2001/XMLSchema-instancexsi:schemaLocationhttp://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdbean iddemo classcom.wangjiafu.spring.MyTestBean namedemo1,demo2property namebeanName valuebean demo1//beanbeans/beans
/beans 与单独的配置文件并没有太大差别无非是递归调用beans的解析过程。
