spring xml文件默认标签的解析流程

这一切都要从连跪开始，白银守门员

现在所有关于spring的文章，后面都会重新进行整理，这里只是做个记录。直到我熟悉完ioc，我会把之前的文章都串起来。
解析xml标签要从DefaultBeanDefinitionDocumentReader这个类中的 parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate)方法讲起了。具体如下：

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)) {
			/**
			 * 重点看一下bean标签的解析
			 */
			processBeanDefinition(ele, delegate);
		}
		// beans 标签
		else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
			// recurse
			doRegisterBeanDefinitions(ele);
		}
	}

可以看出就是对import，alias，bean，beans四个标签进行处理，我们重点看这个bean标签的解析，其它的应该就会迎刃而解。代码如下：

	protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
		/**
		 * 将 <bean /> 节点中的信息提取出来，然后封装到一个 BeanDefinitionHolder 中
		 * Property	 bean中的属性定义
		 * class	类的全限定名
		 * name	可指定 id、name(用逗号、分号、空格分隔)
		 * scope	作用域
		 * constructor arguments	指定构造参数
		 * properties	设置属性的值
		 * autowiring mode	no(默认值)、byName、byType、 constructor
		 * lazy-initialization mode	是否懒加载(如果被非懒加载的bean依赖了那么其实也就不能懒加载了)
		 * initialization method	bean 属性设置完成后，会调用这个方法
		 * destruction method	bean 销毁后的回调方法
		 *
		 *下面是一个bean的定义
		 * <bean id="exampleBean" name="name1, name2, name3" class="com.javadoop.ExampleBean"
		 *       scope="singleton" lazy-init="true" init-method="init" destroy-method="cleanup">
		 *
		 *     <!-- 可以用下面三种形式指定构造参数 -->
		 *   <constructor-arg type="int" value="7500000"/>
		 *     <constructor-arg name="years" value="7500000"/>
		 *     <constructor-arg index="0" value="7500000"/>
		 *
		 *     <!-- property 的几种情况 -->
		 *     <property name="beanOne">
		 *         <ref bean="anotherExampleBean"/>
		 *     </property>
		 *     <property name="beanTwo" ref="yetAnotherBean"/>
		 *     <property name="integerProperty" value="1"/>
		 * </bean>
		 *
		 * bdHolder实例 已经包含class name id alias等类的属性了
		 */
		BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
		if (bdHolder != null) {
			/**
			 * 如果有自定义属性的话，进行相应的解析
			 */
			bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
			try {
				// Register the final decorated instance.
				/**
				 * 这一步 将解析后的bdHolder进行注册
				 */
				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));
		}
	}

逻辑如下：

1. 委托BeanDefinitionParserDelegate中的parseBeanDefinitionElement()方法进行元素解析。
2. 返回的bdHolder不为空的情况下若存在默认标签的子节点下再有自定义属性，还需要对自定义标签进行解析。
3. 解析完后，对解析后的bdHolder进行注册。
4. 发出响应事件，通知相关的监听器。

下面对parseBeanDefinitionElement()方法进行解析：

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
		String id = ele.getAttribute(ID_ATTRIBUTE);
		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;
		/**
		 * 如果没有指定id, 那么用别名列表的第一个名字作为beanName
		 */
		if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
			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) {
			checkNameUniqueness(beanName, aliases, ele);
		}

		/**
		 * 这里就是解析<bean>...<bean/>中的配置信息了
		 */
		AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
		/**
		 * 到这里，整个 <bean /> 标签就算解析结束了，一个 BeanDefinition 就形成了
		 */
		if (beanDefinition != null) {
			/**
			 * 如果都没有设置 id 和 name，那么此时的 beanName 就会为 null，进入下面这块代码产生
			 */
			if (!StringUtils.hasText(beanName)) {
				try {
					if (containingBean != null) {
						/**
						 * bean名称生成方式
						 */
						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);
			return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
		}

		return null;
	}

流程如下：

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

下面对这个类中的parseBeanDefinitionElement(ele, beanName, containingBean)方法进行解析：

public AbstractBeanDefinition parseBeanDefinitionElement(
			Element ele, String beanName, @Nullable BeanDefinition containingBean) {

		this.parseState.push(new BeanEntry(beanName));

		String className = null;
		if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
			className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
		}
		String parent = null;
		if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
			parent = ele.getAttribute(PARENT_ATTRIBUTE);
		}

		try {
			/**
			 * 创建 BeanDefinition，然后设置类信息而已
			 */
			AbstractBeanDefinition bd = createBeanDefinition(className, parent);
			/**
			 * 设置 BeanDefinition 的一堆属性，这些属性定义在 AbstractBeanDefinition 中
			 */
			parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
			bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));

			/**
			 * 下面的一堆是解析 <bean>......</bean> 内部的子元素，
			 * 解析出来以后的信息都放到 bd 的属性中
			 */

			/**
			 * 解析 <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;
	}

从这个方法我们基本就能够看到bean的所有标签了。
话说至此，发现前面的beanDefinition用到的是GenericBeanDefinition，这个类是2.5版本后加入的bean文件配置属性定义类，是一站式服务类 。有兴趣的可以看一下相应的 标签都是怎么解析的，我懒得看了。至此，默认标签解析完成。下面一个方法delegate.decorateBeanDefinitionIfRequired(ele, bdHolder)方法，解析默认标签中的自定义标签元素，感觉不是我需要的，跳过，进去下面一个重要方法BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry())，将解析过的bdHolder进行注册，代码如下：

public static void registerBeanDefinition(
			BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
			throws BeanDefinitionStoreException {

		// Register bean definition under primary name.
		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);
			}
		}
	}

没有什么好说的，直接进去重点方法：

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 {
				/**
				 * 注册前的最后一次校验，这次校验不同于之前的xml文件校验
				 * 主要是对AbstractBeanDefinition属性中的methodOverrides校验
				 * 校验methodOverrides 是否与工厂方法并存或者methOverrides对应的方法根本不存在
				 */
				((AbstractBeanDefinition) beanDefinition).validate();
			}
			catch (BeanDefinitionValidationException ex) {
				throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
						"Validation of bean definition failed", ex);
			}
		}

		BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
		if (existingDefinition != null) {
			/**
			 *如果不允许覆盖 则直接抛异常
			 */
			if (!isAllowBeanDefinitionOverriding()) {
				throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
			}
			/**
			 * 用框架的bean去覆盖用户自定义的bean
			 */
			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 + "]");
				}
			}
			/**
			 * 用新的bean去覆盖旧的bean
			 */
			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 {
				/**
				 * 用同等的bean去覆盖旧的bean
				 */
				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 开始初始化了.
			 * 注意，"注册Bean" 这个动作结束，Bean 依然还没有初始化.
			 * 在 Spring 容器启动的最后，会预初始化 所有的 singleton beans
			 */
			if (hasBeanCreationStarted()) {
				// Cannot modify startup-time collection elements anymore (for stable iteration)
				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;
					removeManualSingletonName(beanName);
				}
			}
			else {
				/**
				 * 最正常的会走到这里
				 * 将BanDefinition放入到一个map当中，这个map保存了所有的BeanDefinition
				 */
				// Still in startup registration phase
				this.beanDefinitionMap.put(beanName, beanDefinition);
				/**
				 * 这个ArrayList会按照配置的顺序保存每一个注册bean的名字
				 */
				this.beanDefinitionNames.add(beanName);
				/**
				 * 手动注入的bean，就是调用registerSingleton(String beanName, Object singletonObject)方法实现的
				 */
				removeManualSingletonName(beanName);
			}
			this.frozenBeanDefinitionNames = null;
		}

		if (existingDefinition != null || containsSingleton(beanName)) {
			resetBeanDefinition(beanName);
		}
	}

流程如下：

• 对AbstractBeanDefinition的校验。这里的校验是针对AbstractBeanDefinition的methodOverrides属性的。
• 对beanName已经注册的情况的处理。如果设置了不允许bean的覆盖，则需要抛出异常，否则直接覆盖。
• 加到map缓存。
• 清除解析之前留下的对应beanName的缓存。

下面的一个别名注册，就不用看了，大概说一下：

• alias与beanName相同情况处理。若alias与beanName并名称相同则不需要处理并删除原来的alias
• alias覆盖处理。若aliasName 已经使用并已经指向了另一beanName则需要用户设置进行处理
• alias循环检查 。当A->B 存在时，若再次出现 A->C->B时候则会抛出异常。
• 注册alias。

最后一步，就是通知监听器解析及注册完成。

参考：spring（第2版） 源码深度解析