spring源码学习二：spring对默认标签的解析

PS：本文参照《Spring源码深度解析2》与spring官方，仅作个人学习

注意:本文分析的是spring的配置文件已经被加载到内存后转换成Element元素的时候，对其进行注册到BeanDefinitonRegistry的过程

默认标签包括：import、alias、bean、beans

解析方法：DefaultBeanDefinitionDocumentReader.parseDefaultElement(ele, 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)) {
      processBeanDefinition(ele, delegate);
   }
    //解析beans标签
   else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
      // recurse
      doRegisterBeanDefinitions(ele);
   }
}

先了解一下什么是BeanDefinition

官方API: https://docs.spring.io/spring-framework/docs/5.3.10-SNAPSHOT/javadoc-api/

/**BeanDefinition描述bean实例，该实例具有属性值、构造函数参数值和具体实现提供的进一步信息。
 * A BeanDefinition describes a bean instance, which has property values,
 * constructor argument values, and further information supplied by
 * concrete implementations.
 *这只是一个最小的接口:主要目的是允许BeanFactoryPostProcessor内省和修改属性值和其他bean元数据。
 * <p>This is just a minimal interface: The main intention is to allow a
 * {@link BeanFactoryPostProcessor} to introspect and modify property values
 * and other bean metadata.
 *
 * @author Juergen Hoeller
 * @author Rob Harrop
 * @since 19.03.2004
 * @see ConfigurableListableBeanFactory#getBeanDefinition
 * @see org.springframework.beans.factory.support.RootBeanDefinition
 * @see org.springframework.beans.factory.support.ChildBeanDefinition
 */
public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {

BeanDefinition是配置文件中元素标签在容器中的内部表示形式，元素标签拥有class、name、scope等属性，BeanDefinition则拥有beanClass、beanClassName、scope等属性 两者是一一对应的。

BeanDefinition在spring存在三种实现，

• RootBeanDefinition: 最常见的，对应一般性的标签
• ChildBeanDefinition:　ChildBeanDefinition相当于一个子类，不可以单独存在，必须要依赖一个父BeanDetintion。（最大的区别他的parentName属性是通过构造方法设置的，而且并没有提供一个无参构造方法给我们。)
• GenericBeanDefinition: 是一站式服务类

​ 在配置文件中可以定义父和子,父用 RootBeanDefinition表示，而子用ChildBeanDefiniton表示，而没有父的就使用RootBeanDefinition表示。AbstractBeanDefinition对两者共同的类信息进行抽象。

​ Spring通过BeanDefinition 将配置文件中的配置信息转换为容器的内部表示，并将这些BeanDefiniton注册到BeanDefinitonRegistry中。Spring容器的BeanDefinitionRegistry就像是Spring配置信息的内存数据库，主要是以map的形式保存，后续操作直接从BeanDefinitionRegistry中读取配置信息。

由此可知，要解析属性就得先创建承载属性的实例，也就是创建GenericBeanDefinition类的实例，且看代码部分的实现

protected AbstractBeanDefinition createBeanDefinition(@Nullable String className, @Nullable String parentName)throws ClassNotFoundException {

		return BeanDefinitionReaderUtils.createBeanDefinition(
				parentName, className, this.readerContext.getBeanClassLoader());
	}


	/**
	 * Create a new GenericBeanDefinition for the given parent name and class name,
	 * eagerly loading the bean class if a ClassLoader has been specified.
	 * @param parentName the name of the parent bean, if any
	 * @param className the name of the bean class, if any
	 * @param classLoader the ClassLoader to use for loading bean classes
	 * (can be {@code null} to just register bean classes by name)
	 * @return the bean definition
	 * @throws ClassNotFoundException if the bean class could not be loaded
	 */
	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;
	}

当创建好承载bean的实例后，就会调用parseBeanDefinitionAttributes（） 方法进行对属性的解析了，说是解析，实则就是将ele中的属性值都赋值给BeanDefinition

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.
            //如果父类的BeanDefinition不为空，则默认使用父类的scope属性
			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 (isDefaultValue(lazyInit)) {
			lazyInit = this.defaults.getLazyInit();
		}
    	//若没有设置或者设置未其它属性，都将会设置未false
		bd.setLazyInit(TRUE_VALUE.equals(lazyInit));
		  //解析autowire属性
		String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);
		bd.setAutowireMode(getAutowireMode(autowire));
		 //解析depends_on属性
		if (ele.hasAttribute(DEPENDS_ON_ATTRIBUTE)) {
			String dependsOn = ele.getAttribute(DEPENDS_ON_ATTRIBUTE);
			bd.setDependsOn(StringUtils.tokenizeToStringArray(dependsOn, MULTI_VALUE_ATTRIBUTE_DELIMITERS));
		}
 		//解析autowire-candidate属性
		String autowireCandidate = ele.getAttribute(AUTOWIRE_CANDIDATE_ATTRIBUTE);
		if (isDefaultValue(autowireCandidate)) {
			String candidatePattern = this.defaults.getAutowireCandidates();
			if (candidatePattern != null) {
				String[] patterns = StringUtils.commaDelimitedListToStringArray(candidatePattern);
				bd.setAutowireCandidate(PatternMatchUtils.simpleMatch(patterns, beanName));
			}
		}
		else {
			bd.setAutowireCandidate(TRUE_VALUE.equals(autowireCandidate));
		}
 		//解析primary属性
		if (ele.hasAttribute(PRIMARY_ATTRIBUTE)) {
			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);
		}
		//解析destory-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;
	}

发现了吧，人家解析的标签有这么多，那么我们又了解的有多少

篇幅问题，这里暂且不讨论详细标签，后面单独再研究 吧

一、bean标签的解析以及注册

先上代码

// 类DefaultBeanDefinitionDocumentReader
	/**解析bean元素，并进行注册
	 * Process the given bean element, parsing the bean definition
	 * and registering it with the registry.
	 */
	protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
        //1.1 元素解析为BeanDefinition
		BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
		if (bdHolder != null) {
            //1.2 解析默认标签中的自定义标签
			bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
			try {
				// 1.3 注册解析的BeanDefinition
				BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
			}
			catch (BeanDefinitionStoreException ex) {
				getReaderContext().error("Failed to register bean definition with name '" +
						bdHolder.getBeanName() + "'", ele, ex);
			}
			//1.4 通知监听器解析及注册以及完成
			getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
		}
	}

代码大体逻辑如下：

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

下面我们将逐行对代码进行追踪

1.1 元素解析为BeanDefinition

BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);

	/**解析bean标签
	 * Parses the supplied {@code <bean>} element. May return {@code null}
	 * if there were errors during parse. Errors are reported to the
	 * {@link org.springframework.beans.factory.parsing.ProblemReporter}.
	 */
	@Nullable
	public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
        //获取bean标签的id属性
		String id = ele.getAttribute(ID_ATTRIBUTE);//student
        //获取bean标签的name属性
		String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);//null
		//别名存放集合
		List<String> aliases = new ArrayList<>();
        //如果我们设置了别名会存放到这个集合中
		if (StringUtils.hasLength(nameAttr)) {
             //将 nameAttr 这个字符进行分割,转换成字符串数组(例如: nameArr="m1,m2,m3" ====> {m1,m2,m3}
			String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);//MULTI_VALUE_ATTRIBUTE_DELIMITERS = ",; "
			aliases.addAll(Arrays.asList(nameArr));
		}

		String beanName = id;
        //如果没有设置id属性，只设置了name属性，则取name属性的第一个作为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) {
             // 校验名字的唯一性(校验现在使用的 beanName 是不是已经被加载过的 bean 使用了）
			checkNameUniqueness(beanName, aliases, ele);
		}
		//这行代码往下追下，看下面①
        //将Element中的元素都设置到beanDefinition中去
		AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
		if (beanDefinition != null) {
            //这里是在<bean>中没有设置name属性和id属性的时候的操作
			if (!StringUtils.hasText(beanName)) {
				try {
					if (containingBean != null) {
						beanName = BeanDefinitionReaderUtils.generateBeanName(
								beanDefinition, this.readerContext.getRegistry(), true);
					}
					else {
                        //会将bean的class属性设置为beanName
                          // 如果 Spring 的配置文件中只配了一个 <bean class="com.trg.Student"> 这样的标签
                    // 那么生成的 beanName 和 beanClassName 的值如下:
                    // 1、beanName 为：com.trg.Student#0
                    // 2、beanClassName 为：com.trg.Student
						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);
            //BeanDefinitionHolder我们了解下，看②
			return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
		}

		return null;
	}

总结，这个函数主要的工作为：

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

①

	/**	解析bean定义本身，而不考虑名称或别名。
	 * Parse the bean definition itself, without regard to name or aliases. May return
	 * {@code null} if problems occurred during the parsing of the bean definition.
	 */
	@Nullable
	public AbstractBeanDefinition parseBeanDefinitionElement(
			Element ele, String beanName, @Nullable BeanDefinition containingBean) {
		//将beanName用BeanEntry封装后存到parseState中。
        //parseStat的底层实现是一个linkedList链表
		this.parseState.push(new BeanEntry(beanName));

		String className = null;
        //对配置文件中的class属性去掉空格
		if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
			className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
		}
        //检查当前beanName有没有parent属性
		String parent = null;
		if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
			parent = ele.getAttribute(PARENT_ATTRIBUTE);
		}

		try {
            //通过当前类名和给定的父类来创建一个BeanDefinition
			AbstractBeanDefinition bd = createBeanDefinition(className, parent);
			//将ele中的属性设置给BeanDefinition
			parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
			bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
            
            //开始解析bean下的标签
			//解析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);

            //将resource资源存到bd中
			bd.setResource(this.readerContext.getResource());
			bd.setSource(extractSource(ele));

			return bd;
		}
		//...此处忽略百字异常捕获的
	}

②

/**
*带有名称和别名的bean定义的Holder。可以注册为内部bean的占位符。
也可用于内部bean定义的编程注册。如果您不关心BeanNameAware之类的东西，那么注册RootBeanDefinition或ChildBeanDefinition就足够了
*
**/
public class BeanDefinitionHolder implements BeanMetadataElement {
	//BeanDefinition对象，里面存储的从配置文件解析的bean，就是我们常说的bean
	private final BeanDefinition beanDefinition;
	// bean的名字
	private final String beanName;
	// bean的别名		
	@Nullable
	private final String[] aliases;


	/**
	 * Create a new BeanDefinitionHolder.
	 * @param beanDefinition the BeanDefinition to wrap
	 * @param beanName the name of the bean, as specified for the bean definition
	 * @param aliases alias names for the bean, or {@code null} if none
	 */
	public BeanDefinitionHolder(BeanDefinition beanDefinition, String beanName, @Nullable String[] aliases) {
		Assert.notNull(beanDefinition, "BeanDefinition must not be null");
		Assert.notNull(beanName, "Bean name must not be null");
		this.beanDefinition = beanDefinition;
		this.beanName = beanName;
		this.aliases = aliases;
	}

1.2 解析默认标签中的自定义标签元素

bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);

先清楚一个问题，这行代码的适用场景

   <bean id="student" class="com.trg.entity.Student"  >
        <mybean:user username = "abc"/>
   </bean>

类似这种，mybean:user为我们自定的标签

注意：这里的自定义类型只是自定义了属性，前面说的自定义是指bean,所以不存在冲突

继续追踪代码

	/**如果适用的话，通过名称空间处理程序修饰给定的bean定义。
	 * Decorate the given bean definition through a namespace handler, if applicable.
	 * @param ele the current element
	 * @param originalDef the current bean definition
	 * @return the decorated bean definition
	 */
	public BeanDefinitionHolder decorateBeanDefinitionIfRequired(Element ele, BeanDefinitionHolder originalDef) {
		return decorateBeanDefinitionIfRequired(ele, originalDef, null);
	}

​

	/**
	 * Decorate the given bean definition through a namespace handler, if applicable.
	 * @param ele the current element
	 * @param originalDef the current bean definition
	 * @param containingBd the containing bean definition (if any) 包含的bean定义(如果有的话)
	 * @return the decorated bean definition
	 */
	public BeanDefinitionHolder decorateBeanDefinitionIfRequired(
			Element ele, BeanDefinitionHolder originalDef, @Nullable BeanDefinition containingBd) {

		BeanDefinitionHolder finalDefinition = originalDef;

		// Decorate based on custom attributes first.
        //遍历所有的属性，看看是否有适用于修饰的属性
		NamedNodeMap attributes = ele.getAttributes();
		for (int i = 0; i < attributes.getLength(); i++) {
			Node node = attributes.item(i);
			finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);
		}

		// Decorate based on custom nested elements.
         //遍历所有的属性，看看是否有适用于修饰的子元素
		NodeList children = ele.getChildNodes();
		for (int i = 0; i < children.getLength(); i++) {
			Node node = children.item(i);
			if (node.getNodeType() == Node.ELEMENT_NODE) {
				finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);
			}
		}
		return finalDefinition;
	}

​ 程序走到这里，条理其实已经非常清楚了，首先获取属性或者元素的命名空间，以此来判断该元素或者属性是否适用于自定义标签的解析条件，找出自定义类型所对应的NamespaceHandler并进行进一步解析。

​ 从 decorateBeanDefinitionIfRequired()方法中知道对于程序默认的标签的处理其实是直接略过的，因为默认的标签到这里已经被处理完了，这里只对自定义的标签或者说对bean的自定义属性感兴趣。在方法中实现了寻找，
自定义标签并根据自定义标签寻找命名空间处理器，并进行进一步的解析。

继续追踪decorateIfRequired()方法

	/**如果适用的话，通过名称空间处理程序修饰给定的bean定义。
	 * Decorate the given bean definition through a namespace handler,
	 * if applicable.
	 * @param node the current child node
	 * @param originalDef the current bean definition
	 * @param containingBd the containing bean definition (if any)
	 * @return the decorated bean definition
	 */
	public BeanDefinitionHolder decorateIfRequired(
			Node node, BeanDefinitionHolder originalDef, @Nullable BeanDefinition containingBd) {
		//获取自定义标签的命名空间
		String namespaceUri = getNamespaceURI(node);//null
		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/schema/")) {
				error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", node);
			}
			else {
				// A custom namespace, not to be handled by Spring - maybe "xml:...".
				if (logger.isDebugEnabled()) {
					logger.debug("No Spring NamespaceHandler found for XML schema namespace [" + namespaceUri + "]");
				}
			}
		}
		return originalDef;
	}

这个方法的主要功能就是先找到自定义标签的命名空间，然后根据命名空间找到对应的处理器，通过处理器进行修饰。

至此，XML解析工作已经完成了，装饰的也装饰完成了。下面将会进行注册了

1.3 注册解析的BeanDefinition

BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder,getReaderContext().getRegistry());

	/**将给定的bean定义注册到给定的bean工厂。
	 * Register the given bean definition with the given bean factory.
	 * @param definitionHolder the bean definition including name and aliases
	 			定义包含名称和别名的bean定义
	 * @param registry the bean factory to register with 注册要注册的bean工厂
	 * @throws BeanDefinitionStoreException if registration failed
	 */
	public static void registerBeanDefinition(
			BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
			throws BeanDefinitionStoreException {

		// Register bean definition under primary name.
        //使用beanName作为唯一标识进行注册
		String beanName = definitionHolder.getBeanName();
		registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

		// Register aliases for bean name, if any.
        //如果有别名的话，则使用别名进行注册
		String[] aliases = definitionHolder.getAliases();
		if (aliases != null) {
			for (String alias : aliases) {
				registry.registerAlias(beanName, alias);
			}
		}
	}

继续追踪下代码，这里是进入了默认注册的类DefaultListableBeanFactory

	@Override
	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文件校验，
                *主要是对于AbstractBeanDe finition属性中的methodoverrides校验，
				*校验methodOverrides是否与工厂方法并存或者methodOverr ides对应的方法根本不存在
                ***/
				((AbstractBeanDefinition) beanDefinition).validate();
			}
			catch (BeanDefinitionValidationException ex) {
				throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
						"Validation of bean definition failed", ex);
			}
		}
		//从已经注册的beanDefinitionMap中去查找当前bean是否已经存在了
		BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
        //表示已经存在 了
		if (existingDefinition != null) {
            // //如果Spring配置了不允许BeanDefinition覆盖，已经注册过，现在该beanName又尝试注册就抛出BeanDefinitionOverrideException
			if (!isAllowBeanDefinitionOverriding()) {
				throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
			}
            /**
                 * BeanDefinition.role是Spring提供给用户自定义的字段
                 * 此处判断如果新覆盖的BeanDefinition角色>旧的BeanDefinition角色就输出一段info级别的日志
                 */

			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 + "]");
				}
			}
             //如果新覆盖的BeanDefinition与旧的BeanDefinition不相同就输出一段debug级别的日志
			else if (!beanDefinition.equals(existingDefinition)) {
				if (logger.isDebugEnabled()) {
					logger.debug("Overriding bean definition for bean '" + beanName +
							"' with a different definition: replacing [" + existingDefinition +
							"] with [" + beanDefinition + "]");
				}
			}
             //输出一段该beanName被覆盖的trace级别日志
			else {
				if (logger.isTraceEnabled()) {
					logger.trace("Overriding bean definition for bean '" + beanName +
							"' with an equivalent definition: replacing [" + existingDefinition +
							"] with [" + beanDefinition + "]");
				}
			}
             //如果对应的beanName存在于beanDefinitionMap且允许覆盖则将新的beanDefinition放入到beanDefinitionMap中
			this.beanDefinitionMap.put(beanName, beanDefinition);
		}
        //表示不存在，还没注册过
		else {
            //hasBeanCreationStarted检查该工厂的bean创建阶段是否已经启动，即是否有任何bean在此期间被标记为已创建。
			if (hasBeanCreationStarted()) {
				// Cannot modify startup-time collection elements anymore (for stable iteration)
                //如果有其它bean也在创建过程中。
				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 {
				// Still in startup registration phase
                //bean定义对象的映射，按bean名称键控。
				this.beanDefinitionMap.put(beanName, beanDefinition);
                //将beanName都存储到beanDefinitionNames的List集合当中去
				this.beanDefinitionNames.add(beanName);
                //这里应该是移除了单例的bean，留坑
				removeManualSingletonName(beanName);
			}
			this.frozenBeanDefinitionNames = null;
		}
            /**
             * 如果该BeanDefinition注册过，则在mergedBeanDefinitions中会有缓存
             * 如果该beanName曾经是单体对象，上面只是remove manualSingletonNames,还需要清空singletonObjects等等，singletonObjects是Spring单例Bean的三层缓存中第一层，三层缓存可以解决循环依赖问题
             * resetBeanDefinition就是负责清空这些
             */ 
		if (existingDefinition != null || containsSingleton(beanName)) {
			resetBeanDefinition(beanName);
		}
	}

该方法主要的实现：

• 对于AbstractBeanDe finition属性中的methodoverrides校验

• 判断是否在beanDefinitionMap中已经注册过beanName了

  注册过则进行覆盖

  未注册过则注册

• 清除解析之前留下的对应beanName的缓存

  PS:这里有几个问题后面需再仔细研究一下

  1、如果当前beanName=student正在清楚缓存的时候，同时另外一个也是beanName=student的注册进来了，会出现什么问题？

  2、removeManualSingletonName的具体实现

1.4 通知监听器解析及注册已经完成

通过代码getReaderContext(). fireComponentRegistered(new BeanComponentDefinition(bdHolder))
完成此工作，这里的实现只为扩展，当程序开发人员需要对注册BeanDefinition事件进行监听
时可以通过注册监听器的方式并将处理逻辑写人监听器中，目前在Spring中并没有对此事件做
任何逻辑处理。

二、alias标签的解析

	/**处理给定的alias元素，向注册中心注册别名
	 * Process the given alias element, registering the alias with the registry.
	 */
	protected void processAliasRegistration(Element ele) {
        //获取name属性
		String name = ele.getAttribute(NAME_ATTRIBUTE);
        //获取别名的属性
		String alias = ele.getAttribute(ALIAS_ATTRIBUTE);
		boolean valid = true;
        //校验name属性不能为空
		if (!StringUtils.hasText(name)) {
			getReaderContext().error("Name must not be empty", ele);
			valid = false;
		}
        //校验alias标签不能为空，因为你既然要解析alias标签，你首先就不能为空啊
		if (!StringUtils.hasText(alias)) {
			getReaderContext().error("Alias must not be empty", ele);
			valid = false;
		}
		if (valid) {
			try {
                //2.1注册alias
				getReaderContext().getRegistry().registerAlias(name, alias);
			}
			catch (Exception ex) {
				getReaderContext().error("Failed to register alias '" + alias +
						"' for bean with name '" + name + "'", ele, ex);
			}
            //2.2别名注册后通知监听器做相应的处理
			getReaderContext().fireAliasRegistered(name, alias, extractSource(ele));
		}
	}

2.1注册alias

	/** Map from alias to canonical name. */
	private final Map<String, String> aliasMap = new ConcurrentHashMap<>(16);


	@Override
	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);
				if (logger.isDebugEnabled()) {
					logger.debug("Alias definition '" + alias + "' ignored since it points to same name");
				}
			}
			else {
				String registeredName = this.aliasMap.get(alias);
				if (registeredName != null) {
					if (registeredName.equals(name)) {
						// An existing alias - no need to re-register
						return;
					}
					if (!allowAliasOverriding()) {
						throw new IllegalStateException("Cannot define alias '" + alias + "' for name '" +
								name + "': It is already registered for name '" + registeredName + "'.");
					}
					if (logger.isDebugEnabled()) {
						logger.debug("Overriding alias '" + alias + "' definition for registered name '" +
								registeredName + "' with new target name '" + name + "'");
					}
				}
				checkForAliasCircle(name, alias);
				this.aliasMap.put(alias, name);
				if (logger.isTraceEnabled()) {
					logger.trace("Alias definition '" + alias + "' registered for name '" + name + "'");
				}
			}
		}
	}

这个是具体的实现，看代码可以知道别名作为key，bean的name作为value存放到了map中。这个跟bean的存放大同小异

2.2别名注册后通知监听器做相应的处理

//这里貌似也没啥具体看的

三、import标签的解析

使用案例

<beans>
    <import resource="services.xml"/>
    <import resource="resources/messageSource.xml"/>
    <import resource="/resources/themeSource.xml"/>

    <bean id="bean1" class="..."/>
    <bean id="bean2" class="..."/>
</beans>

注意，这种可以配置相对路径或者绝对路径的

比如：file:C:/config/services.xmlorclasspath:/config/services.xml

	/**
	 * Parse an "import" element and load the bean definitions
	 * from the given resource into the bean factory.
	 */
	protected void importBeanDefinitionResource(Element ele) {
        //获取import中的resource属性
		String location = ele.getAttribute(RESOURCE_ATTRIBUTE);
        //如果resource属性不存在，则不做任何的处理，直接返回
		if (!StringUtils.hasText(location)) {
			getReaderContext().error("Resource location must not be empty", ele);
			return;
		}

		// Resolve system properties: e.g. "${user.dir}"
        //解析系统属性，格式如: "${user.dir}"
		location = getReaderContext().getEnvironment().resolveRequiredPlaceholders(location);

		Set<Resource> actualResources = new LinkedHashSet<>(4);

		// Discover whether the location is an absolute or relative URI
        //判断路径是绝对URI还是相对URI
		boolean absoluteLocation = false;
		try {
			absoluteLocation = ResourcePatternUtils.isUrl(location) || ResourceUtils.toURI(location).isAbsolute();
		}
		catch (URISyntaxException ex) {
			// cannot convert to an URI, considering the location relative
			// unless it is the well-known Spring prefix "classpath*:"
		}

		// Absolute or relative?
        //如果是绝对路径，则直接根据路径加载URI
		if (absoluteLocation) {
			try {
				int importCount = getReaderContext().getReader().loadBeanDefinitions(location, actualResources);
				if (logger.isTraceEnabled()) {
					logger.trace("Imported " + importCount + " bean definitions from URL location [" + location + "]");
				}
			}
			catch (BeanDefinitionStoreException ex) {
				getReaderContext().error(
						"Failed to import bean definitions from URL location [" + location + "]", ele, ex);
			}
		}
		else {
			// No URL -> considering resource location as relative to the current file.
			try {
                //如果是相对地址，则根据相对地址计算出绝对地址。
				int importCount;
                //Resource存在多个子实现类，如VfsResource、FileSys temResource等，
				//而每个resource的createRelative方式实现都不-样，所以这里先使用子类的方法尝试解析
				Resource relativeResource = getReaderContext().getResource().createRelative(location);
				if (relativeResource.exists()) {
					importCount = getReaderContext().getReader().loadBeanDefinitions(relativeResource);
					actualResources.add(relativeResource);
				}
				else {
                    //如果解析不成功，则使用默认的解析器ResourcePatternResolver进行解析
					String baseLocation = getReaderContext().getResource().getURL().toString();
					importCount = getReaderContext().getReader().loadBeanDefinitions(
							StringUtils.applyRelativePath(baseLocation, location), actualResources);
				}
				if (logger.isTraceEnabled()) {
					logger.trace("Imported " + importCount + " bean definitions from relative location [" + location + "]");
				}
			}
			catch (IOException ex) {
				getReaderContext().error("Failed to resolve current resource location", ele, ex);
			}
			catch (BeanDefinitionStoreException ex) {
				getReaderContext().error(
						"Failed to import bean definitions from relative location [" + location + "]", ele, ex);
			}
		}
        //解析后进行监听器激活处理
		Resource[] actResArray = actualResources.toArray(new Resource[0]);
		getReaderContext().fireImportProcessed(location, actResArray, extractSource(ele));
	}

流程总结：

1. 获取Resource所表示的路径
2. 解析路径中的系统属性，格式如"${user.dir}"
3. 判定location是绝对路径还是相对路径
4. 如果是绝对路径则递归调用bean的解析过程，进行另一次的解析
5. 如果是相对路径则计算出绝对路径并进行解析
6. 通知监听器，解析完成

四、beans标签的解析

<beans>
    <bean id="beanOne" class="x.y.ThingOne">
        <constructor-arg ref="beanTwo"/>
        <constructor-arg ref="beanThree"/>
    </bean>

    <bean id="beanTwo" class="x.y.ThingTwo"/>

    <bean id="beanThree" class="x.y.ThingThree"/>
</beans>

当我们点击进入解析beans标签的方法后，发现它又回到了这个方法中,那就说明对beans的解析是递归进行解析的。

	/**
	 * Parse the elements at the root level in the document:
	 * "import", "alias", "bean".
	 * @param root the DOM root element of the document
	 */
	protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
		if (delegate.isDefaultNamespace(root)) {
			NodeList nl = root.getChildNodes();
			for (int i = 0; i < nl.getLength(); i++) {
				Node node = nl.item(i);
				if (node instanceof Element) {
					Element ele = (Element) node;
					if (delegate.isDefaultNamespace(ele)) {
						parseDefaultElement(ele, delegate);
					}
					else {
						delegate.parseCustomElement(ele);
					}
				}
			}
		}
		else {
			delegate.parseCustomElement(root);
		}
	}