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

三、默认标签的解析 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)) { // recurse doRegisterBeanDefinitions(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实例已经包含了我们配置文件中的各种属性了，例如class，name，id，alias等。当返回的bdHolder不为空的情况下若存在默认标签的子节点下再有自定义属性，还需要再次对自定义标签进行解析。当解析完成后，需要对解析后的bdHolder进行注册，注册过程委托给了BeanDefinitionReaderUtils的registerBeanDefinition方法。最后发出响应事件，通知相关的监听器已经加载完这个Bean了。 时序图如下： 3.1.1 解析BeanDefinition DefaultBeanDefinitionDocumentReader .class 接下来我们就针对具体的方法进行分析，首先我们从元素解析及信息提取开始，也就是BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement（ele），进入 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 属性 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); } // 解析 属性，构造 AbstractBeanDefinition AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean); if (beanDefinition != null) { // 如果 beanName 不存在，则根据Spring中提供的命名规则生成对应的beanName if (!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); // 封装 BeanDefinitionHolder return 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 maDelimitedListToStringArray(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 id="demo" class="com.yhl.myspring.demo.bean.MyBeanDemo"> <property name="beanName" value="bean demo1"/> <meta key="demo" value="demo"/> </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); // 提取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); } } }

3.1.1.4 解析子元素lookup-method 这个方法主要是针对bean中lookup-method子元素的提取。 BeanDefinitionParserDelegate.class //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); } } }

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 { @Override public 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:// .springframework.org/schema/beans" xmlns:xsi="http:// .w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http:// .springframework.org/schema/beans http:// .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 属性中。

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 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对应的bean RuntimeBeanReference 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)) { // 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; } }

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 id="myTestBean" class="com.wangjiafu.spring.MyTestBean"> <qualifier type="org.Springframework.beans.factory.annotation.Qualifier" value="gf" /> </bean> 其解析过程与之前大同小异 这里不再重复叙述。 3.1.2 AbstractBeanDefinition 属性 至此我们便完成了对 XML 文档到 GenericBeanDefinition 的转换， 就是说到这里， XML 中所有的配置都可以在 GenericBeanDefinition的实例类中应找到对应的配置。 GenericBeanDefinition 只是子类实现，而大部分的通用属性都保存在了 AbstractBeanDefinition 中，那么我们再次通过 AbstractBeanDefinition 的属性来回顾一 下我们都解析了哪些对应的配置。 public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor implements BeanDefinition, Cloneable { // 此处省略静态变量以及final变量 @Nullable private volatile Object beanClass; /** * bean的作用范围，对应bean属性scope */ @Nullable private 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 */ @Nullable private 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); @Nullable private 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" /> */ @Nullable private String factoryBeanName; /** * 对应bean属性factory-method */ @Nullable private String factoryMethodName; /** * 记录构造函数注入属性，对应bean属性constructor-arg */ @Nullable private ConstructorArgumentValues constructorArgumentValues; /** * 普通属性集合 */ @Nullable private MutablePropertyValues propertyValues; /** * 方法重写的持有者，记录lookup-method、replaced-method元素 */ @Nullable private MethodOverrides methodOverrides; /** * 初始化方法，对应bean属性init-method */ @Nullable private String initMethodName; /** * 销毁方法，对应bean属性destroy-method */ @Nullable private 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的描述信息 */ @Nullable private String description; /** * 这个bean定义的资源 */ @Nullable private Resource resource; }

3.1.3 默认标签中的自定义标签解析 之前我们已经分析了对于默认标签的解析，我们再次回顾下默认标签解析函数的起始函数，如下图片中有一个方法： delegate.decorateBeanDefinitionIfRequired(ele, bdHolder) DefaultBeanDefinitionDocumentReader.class 这个方法的作用是什么呢？首先我们看下这种场景，如下配置文件： <bean id="demo" class="com.wangjiafu.spring.MyTestBean"> <property name="beanName" value="bean demo1"/> <meta key="demo" value="demo"/> <mybean:username="mybean"/> </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:// .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:// .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 与 beanDefinition Assert.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 的 BeanDefinition oldBeanDefinition = 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_INFRASTRUCTURE if (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 + "]"); } } // 允许覆盖，直接覆盖原有的 BeanDefinition this.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 缓存。 其实整段代码的核心就在于 this.beanDefinitionMap.put(beanName, beanDefinition); 。BeanDefinition 的缓存也不是神奇的东西，就是 定义一个 ConcurrentHashMap，key 为 beanName，value 为 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-register return; } 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 id="demo" class="com.wangjiafu.spring.MyTestBean" name="demo1,demo2"> <property name="beanName" value="bean demo1"/> </bean> 在Spring还有另外一种声明别名的方式： <bean id="myTestBean" class="com.wangjiafu.spring.MyTestBean"/> <alias name="myTestBean" alias="testBean1,testBean2"/> 我们具体看下alias标签的解析过程，解析使用的方法processAliasRegistration(ele)，方法体如下： # DefaultBeanDefinitionDocumentReader 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 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)); } } 通过代码可以发现解析流程与bean中的alias解析大同小异，都是将 beanName与别名alias组成一对注册到registry中。跟踪代码最终使用了 SimpleAliasRegistry中的 registerAlias(String name, String alias)方法。 3.3 import标签的解析 DefaultBeanDefinitionDocumentReader.class

对于Spring配置文件的编写，经历过大型项目的人都知道，里面有太多的配置文件了。基本采用的方式都是分模块，分模块的方式很多，使用import就是其中一种，例如我们可以构造这样的Spring配置文件： <?xml version="1.0" encoding="UTF-8" ?> <beans xmlns="http:// .springframework.org/schema/beans" xmlns:xsi="http:// .w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http:// .springframework.org/schema/beans http:// .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> 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); 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)); } 解析 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 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; } } 整个逻辑比较简单，首先获取 ResourceLoader，然后根据不同的 ResourceLoader 执行不同的逻辑，主要是可能存在多个 Resource，但是最终都会回归到 XmlBeanDefinitionReader.loadBeanDefinitions() ，所以这是一个 递归的过程。 至此，import 标签解析完毕，整个过程比较清晰明了： 获取 source 属性值得到正确的资源路径调用 loadBeanDefinitions() 方法进行递归的 BeanDefinition 加载。 3.4 嵌入式beans标签的解析 DefaultBeanDefinitionDocumentReader.class

类似import标签所提供的功能，如下： <?xml version="1.0" encoding="UTF-8" ?> <beans xmlns="http:// .springframework.org/schema/beans" xmlns:xsi="http:// .w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http:// .springframework.org/schema/beans http:// .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的解析过程。