Spring源码03---parseDefaultElement

首先让我们回到 https://www.cnblogs.com/xiaomaomao/p/14106990.html 文末的 parseBeanDefinitions 方法,这个方法主要是解析 beans 标签下面默认的标签(beans、import、alias、bean)

代码块一、parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate)

// DefaultBeanDefinitionDocumentReader 类中的方法
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
	// 1、判断当前是否是默认的命名空间, Spring 配置文件默认的命名空间如下:
	// xmlns="http://www.springframework.org/schema/beans" ,因为它不包含前缀 xnlns:前缀
    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)) {
                    // 1.1、解析默认名称空间下面的默认元素,包括 import、alias、beans、bean ---- (详情见代码块二)
                    parseDefaultElement(ele, delegate);
                }
                else {
                    // 1.2、解析默认名称空间下面的自定义元素,包括 context、tx... 等
                    delegate.parseCustomElement(ele);
                }
            }
        }
    }
    else {
        // 2、解析自定义命名空间下的元素
        delegate.parseCustomElement(root);
    }
}

本文主要是为了弄清楚 Spring 是如何解析这些默认的元素的,对应的代码是 parseDefaultElement(ele, delegate), 这里面包含了 Spring beans 标签下的所有默认的标签的解析,包括我们最常用,也最重要的 bean 标签的解析

代码块二、parseDefaultElement(ele, delegate)

// DefaultBeanDefinitionDocumentReader 类中的方法
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
	// 1、解析 import 标签
	if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
		importBeanDefinitionResource(ele);
	}
	// 2、解析 alias 标签
	else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
		processAliasRegistration(ele);
	}
	// 3、解析 bean 标签,这个是我们最常用也最核心的,因为我们在 Spring 配置文件中配置最多的就是 bean 标签
	// 注意:这里解析的是 beans 标签中的一个 bean 标签
	// 我们这里就着重看一下是如何解析 bean 标签的 ---- (详细见代码块三)
	else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
		processBeanDefinition(ele, delegate);
	}
	// 4、解析 beans 标签
	else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
		// 4.1、递归调用,因为默认的命名空间是 beans , beans 标签中是可以嵌套 beans 标签的
		// 所以需要递归调用解析 beans 标签里面的 beans 标签里面的标签
		doRegisterBeanDefinitions(ele);
	}
}

代码块三、processBeanDefinition(ele, delegate)

// DefaultBeanDefinitionDocumentReader 类中的方法
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
	// 1、解析一个 bean 标签,并且将解析好的数据封装在 BeanDefinitionHolder 对象中 ---- (详情见代码块四)
	BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
	if (bdHolder != null) {
		// 2、若存在默认标签的子节点下再有自定义属性,需要再次对自定义标签再进行解析(基本不用,不做深入解析)
		bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
		try {
			// 3、注册 BeanDefinition ---- (详情见代码块八)
			BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
		}
		catch (BeanDefinitionStoreException ex) {
			getReaderContext().error("Failed to register bean definition with name '" +
					bdHolder.getBeanName() + "'", ele, ex);
		}
		// 4、发送注册事件
		getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
	}
}

在解析 bean 标签之前,我们先去看一下我们用的最多的 bean 标签,它里面到底可以配置什么信息.

bean 标签中可以配置的属性如下:

 bean 标签中可以配置的子标签如下:

在执行 BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele) 这句代码之前,我们需要去看一下BeanDefinitionHolder 这个类,打开这个类,可以发现这个类总共就只有三个属性, beanName、aliases、beanDefinition ,其中最重要的就是 beanDefinition,它封装的是 bean 定义信息,也就是它可以封装 bean 标签中的除了 id 、name属性之外的所有属性,以及封装 bean 标签下面的子标签中的数据信息

然后我们再去看一下 BeanDefinition 这个类,并且结合上图中的 bean 标签里面可以配置的属性值一起看,我们会发现, BeanDefiniton 实际上可以看做是对应 bean 标签的一个实例.

public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {
	// 1、默认的 scope 只支持 singleton 和 prototype 两种,
	// request, session, globalSession, application, websocket ... 这些属于 web 的扩展
	String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON;
	String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE;
	// 2、应用的角色
	int ROLE_APPLICATION = 0;
	// 3、支持的角色
	int ROLE_SUPPORT = 1;
	// 4、基础架构角色
	int ROLE_INFRASTRUCTURE = 2;
	// 5、获取父 bean ,这里的父 bean ,不是 java 中继承关系的父类,它代表的是继承父 bean 中的属性
	// 对应的是 bean 标签中的 parent 属性,定义父 bean 仅仅是为了继承父 bean 的属性而已,子 bean 和
	// 父 bean 不需要存在继承关系
	String getParentName();
	// 6、设置 Bean 的类名称,将来是要通过反射来生成实例的
	void setBeanClassName(String beanClassName);
	String getBeanClassName();
	// 7、设置 bean 的 scope 属性
	void setScope(String scope);
	String getScope();
	void setLazyInit(boolean lazyInit);
	// 8、设置是否懒加载初始化
	boolean isLazyInit();
	// 9、设置该 Bean 依赖的所有的 Bean ,注意:这里的依赖不是指属性依赖(如 @Autowire 标记的)
	// 而是 bean 标签里面的 depends-on="" 属性设置的值.
	void setDependsOn(String... dependsOn);
	String[] getDependsOn();
	void setAutowireCandidate(boolean autowireCandidate);
	// 10、是否可以通过 @Atuowired 自动装配
	boolean isAutowireCandidate();
	void setPrimary(boolean primary);
	// 11、是否是主要的,同一接口的多个实现,如果不指定名字的话, Spring 会优先选择设置 primary 为 true 的 bean
	boolean isPrimary();
	// 12、设置工厂 bean 的名称,在 Spring 中,不是所有的 bean 都是通过反射生成的,也可以通过工厂 bean 来生成
	void setFactoryBeanName(String factoryBeanName);
	String getFactoryBeanName();
	// 13、设置工厂 bean 的方法名
	void setFactoryMethodName(String factoryMethodName);
	String getFactoryMethodName();
	// 14、构造参数注入值
	ConstructorArgumentValues getConstructorArgumentValues();
	// 15、Property 属性注入值
	MutablePropertyValues getPropertyValues();
	boolean isSingleton();
	boolean isPrototype();
	// 16、如果这个 Bean 是被设置为 abstract ,那么不能实例化,常用于作为父 bean 用于继承,其实也很少用......
	boolean isAbstract();
	int getRole();
	String getDescription();
	String getResourceDescription();
	BeanDefinition getOriginatingBeanDefinition();
}

看完了 BeanDefinitionHolder 和 BeanDefinition  ,我们接着回到代码吧

代码块四、parseBeanDefinitionElement(ele)

// BeanDefinitionParserDelegate 类中的方法
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
	// 1、获取该 bean 标签中的 id 属性值
	String id = ele.getAttribute(ID_ATTRIBUTE);
	// 2、获取 bean 标签的 name 属性值
	String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
	// 3、如果 bean 标签中配置了<bean name="m1,m2;m3;m4" class="com.xiaomaomao.entity.Mango" >
	// 它会使用 , ; 进行分割,并且将分割后的 m1 m2 m3 m4 存入 List 集合 aliases 中
	List<String> aliases = new ArrayList<String>();
	if (StringUtils.hasLength(nameAttr)) {
		String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
		aliases.addAll(Arrays.asList(nameArr));
	}
	// 4、将 id 值赋值给 beanName 属性
	String beanName = id;
	// 5、如果 bean 标签中没有配置 id 属性,只配置了 name 属性
	if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
		// 5.1、那么就将 name 属性的第一个值作为 beanName , 剩下的作为 别名
		beanName = aliases.remove(0);
		if (logger.isDebugEnabled()) {
			logger.debug("No XML 'id' specified - using '" + beanName +
					"' as bean name and " + aliases + " as aliases");
		}
	}

	if (containingBean == null) {
		// 6、校验 beanName 和 aliases 的唯一性
		checkNameUniqueness(beanName, aliases, ele);
	}
	// 7、解析 bean 定义元素 ---- (详情见代码块五)
	AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
	if (beanDefinition != null) {
		// 8、如果 bean 标签中既没有配置 id 也没有配置 name 属性
		// <bean class="com.xiaomaomao.entity.Mango">
		if (!StringUtils.hasText(beanName)) {
			try {
				// 8.1、如果包含内部 bean 的情况下
				if (containingBean != null) {
					beanName = BeanDefinitionReaderUtils.generateBeanName(
							beanDefinition, this.readerContext.getRegistry(), true);
				}
				else {
					// 8.2 、不包含内部 bean 的情况下, Spring 会根据自己的规则生成 beanName
					// beanName : com.xiaomaomao.entity.Mango#0
					beanName = this.readerContext.generateBeanName(beanDefinition);
					// 8.3、使用 beanClassName 作为别名
					// beanClassName : com.xiaomaomao.entity.Mango
					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()) {
					logger.debug("Neither XML 'id' nor 'name' specified - " +
							"using generated bean name [" + beanName + "]");
				}
			}
			catch (Exception ex) {
				error(ex.getMessage(), ele);
				return null;
			}
		}
		// 9、将存放所有别名的 List 集合转化为 String 类型的数组
		String[] aliasesArray = StringUtils.toStringArray(aliases);
		// 10、返回 BeanDefinitionHolder 对象
		return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
	}
	return null;
}

代码块五、parseBeanDefinitionElement(ele, beanName, containingBean)

// BeanDefinitionParserDelegate 类中的方法
public AbstractBeanDefinition parseBeanDefinitionElement(
			Element ele, String beanName, BeanDefinition containingBean) {
	// 1、将 beanName 封装进 BeanEntry 的 beanDefinitionName 属性中,然后再存入本类的 ParseState 中
	this.parseState.push(new BeanEntry(beanName));

	String className = null;
	// 2、如果 bean 标签中配置了 class 属性,获取到 class 属性配置的值
	if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
		className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
	}
	
	try {
		String parent = null;
		// 3、判断 bean 标签中是否配置了 parent 属性
		if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
			parent = ele.getAttribute(PARENT_ATTRIBUTE);
		}
		// 4、创建一个可以承载 bean 标签数据的 AbstractBeanDefinition 对象,并设置 beanClass 属性 ---- (详情见代码块六)
		AbstractBeanDefinition bd = createBeanDefinition(className, parent);
		// 5、解析 bean 标签的剩余属性 ---- (详情见代码块七)
		parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
		// 6、封装 description 属性
		bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
		// 7、解析 bean 标签里面的 meta 标签
		parseMetaElements(ele, bd);
		// 8、解析 bean 标签里面的 lookup - method 标签
		parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
		// 9、解析 bean 标签里面的 replace - method 标签
		parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
		
		// 10、解析 bean 标签里面的 constructor-arg 标签,这个标签很重要,当我们使用有参数构造方法注入值的时候使用该标签
		// 对 bean 对象里面的属性赋值,如果没有有参数构造方法,那么会报错
		parseConstructorArgElements(ele, bd);
		// 11、解析 bean 标签里面的 property 标签,这个标签也很重要,使用 无参数构造方法 和 setxxx 方法对 bean 对象进行赋值
		parsePropertyElements(ele, bd);
		
		// 12、解析 bean 标签里面的 qualifier 标签 
		parseQualifierElements(ele, bd);
		// 13、设置当前 Spring 配置文件的资源路径
		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 {
		// 14、移除 ParseState 中之前存入的 BeanDefinitionName
		this.parseState.pop();
	}

	return null;
}

代码块六、createBeanDefinition(className, parent)

// BeanDefinitionParserDelegate 类中的方法
protected AbstractBeanDefinition createBeanDefinition(String className, String parentName)
		throws ClassNotFoundException {

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

// BeanDefinitionReaderUtils 类中的方法
public static AbstractBeanDefinition createBeanDefinition(
		String parentName, String className, ClassLoader classLoader) throws ClassNotFoundException {
	// 1、新建一个 GenericBeanDefinition 对象用于承载数据,它是 AbstractBeanDefinition 的子类
	GenericBeanDefinition bd = new GenericBeanDefinition();
	// 2、设置 parentName
	bd.setParentName(parentName);
	// 3、如果 bean 标签中配置了 class 属性
	if (className != null) {
		if (classLoader != null) {
			// 3.1、如果 classLoader 不为空,使用反射构建出 BeanClass ,并设置为 GenericBeanDefinition 的属性.
			bd.setBeanClass(ClassUtils.forName(className, classLoader));
		}
		else {
			// 3.2、如果 classLoader 为空,将 className 设置为 GenericBeanDefinition 的属性.
			bd.setBeanClassName(className);
		}
	}
	// 4、返回 GenericBeanDefinition 对象
	return bd;
}

代码块七、parseBeanDefinitionAttributes(ele, beanName, containingBean, bd)

// BeanDefinitionParserDelegate 类中的方法
public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,
		BeanDefinition containingBean, AbstractBeanDefinition bd) {
	// 1、对于 1.0 版本的 singleton 属性 bean 标签已经不支持了,如果你想使用,必须要用 scope="singleton" 去声明
	// 否则会报错,当然 Spring 默认 bean 的 scope 就是 singleton
	if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {
		error("Old 1.x 'singleton' attribute in use - upgrade to 'scope' declaration", ele);
	}
	// 2、将 bean 标签中的 scope 属性对应的值使用 GenericBeanDefinition 对象进行封装
	else if (ele.hasAttribute(SCOPE_ATTRIBUTE)) {
		bd.setScope(ele.getAttribute(SCOPE_ATTRIBUTE));
	}
	// 3、在内部bean定义的情况下,从包含bean接受默认值.
	else if (containingBean != null) {
		bd.setScope(containingBean.getScope());
	}
	// 4、GenericBeanDefinition 对象封装 bean 的 abstract 属性
	if (ele.hasAttribute(ABSTRACT_ATTRIBUTE)) {
		bd.setAbstract(TRUE_VALUE.equals(ele.getAttribute(ABSTRACT_ATTRIBUTE)));
	}
	// 5、Spring 默认不使用懒加载,如果你想使用懒加载初始化,它的值为 false ,如果需要在 bean 标签上明确规定为 true
	// <bean id="mango" name="m1,m2;m3;m4" class="com.xiaomaomao.entity.Mango" lazy-init="true">
	String lazyInit = ele.getAttribute(LAZY_INIT_ATTRIBUTE);
	if (DEFAULT_VALUE.equals(lazyInit)) {
		lazyInit = this.defaults.getLazyInit();
	}
	bd.setLazyInit(TRUE_VALUE.equals(lazyInit));
	// 6、封装 autowire 属性
	String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);
	bd.setAutowireMode(getAutowireMode(autowire));
	// 7、封装 dependency-check 属性
	String dependencyCheck = ele.getAttribute(DEPENDENCY_CHECK_ATTRIBUTE);
	bd.setDependencyCheck(getDependencyCheck(dependencyCheck));
	// 8、封装 depends-on 属性
	if (ele.hasAttribute(DEPENDS_ON_ATTRIBUTE)) {
		String dependsOn = ele.getAttribute(DEPENDS_ON_ATTRIBUTE);
		bd.setDependsOn(StringUtils.tokenizeToStringArray(dependsOn, MULTI_VALUE_ATTRIBUTE_DELIMITERS));
	}
	// 9、封装 autowire-candidate 属性
	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));
	}
	// 10、封装 primary 属性
	if (ele.hasAttribute(PRIMARY_ATTRIBUTE)) {
		bd.setPrimary(TRUE_VALUE.equals(ele.getAttribute(PRIMARY_ATTRIBUTE)));
	}
	// 11、封装 init-method 属性
	if (ele.hasAttribute(INIT_METHOD_ATTRIBUTE)) {
		String initMethodName = ele.getAttribute(INIT_METHOD_ATTRIBUTE);
		if (!"".equals(initMethodName)) {
			bd.setInitMethodName(initMethodName);
		}
	}
	else {
		if (this.defaults.getInitMethod() != null) {
			bd.setInitMethodName(this.defaults.getInitMethod());
			bd.setEnforceInitMethod(false);
		}
	}
	// 12 、封装 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);
		}
	}
	// 13、封装 factory-method 属性
	if (ele.hasAttribute(FACTORY_METHOD_ATTRIBUTE)) {
		bd.setFactoryMethodName(ele.getAttribute(FACTORY_METHOD_ATTRIBUTE));
	}
	// 14、封装 factory-bean 属性
	if (ele.hasAttribute(FACTORY_BEAN_ATTRIBUTE)) {
		bd.setFactoryBeanName(ele.getAttribute(FACTORY_BEAN_ATTRIBUTE));
	}
	// 15、返回封装了 bean 标签中所有属性的 GenericBeanDefinition 对象
	return bd;
}

让我们回到 解析一个 bean 标签开始的位置 BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);

// DefaultBeanDefinitionDocumentReader 类中的方法
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
	// 1、解析一个 bean 标签,并且将解析好的数据封装在 BeanDefinitionHolder 对象中 ---- (详情见代码块四)
	BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
	if (bdHolder != null) {
		// 2、若存在默认标签的子节点下再有自定义属性,需要再次对自定义标签再进行解析(基本不用,不做深入解析)
		bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
		try {
			// 3、注册 BeanDefinition ---- (详情见代码块八)
			BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
		}
		catch (BeanDefinitionStoreException ex) {
			getReaderContext().error("Failed to register bean definition with name '" +
					bdHolder.getBeanName() + "'", ele, ex);
		}
		// 4、发送注册事件
		getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
	}
}

到这里为止整个 BeanDefinitionHolder 对象就全部解析出来了,里面封装了 beanName、aliases、以及 BeanDefinition 对象.

 代码块八、registerBeanDefinition(bdHolder, getReaderContext().getRegistry())

// BeanDefinitionReaderUtils 类中的方法
public static void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
		throws BeanDefinitionStoreException {

	// 1、获取 beanName 
	String beanName = definitionHolder.getBeanName();
	// 2、注册 bean 定义 ---- (详情见代码块九)
	registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

	// 3、获取所有的别名 ---- (详情见代码块十一)
	String[] aliases = definitionHolder.getAliases();
	if (aliases != null) {
		for (String alias : aliases) {
			// 4、依次获取每一个别名,然后注册别名
			registry.registerAlias(beanName, alias);
		}
	}
}

代码块九、registerBeanDefinition(beanName, definitionHolder.getBeanDefinition())

// DefaultListableBeanFactory 类中的方法
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");
	// 1、我们前面创建的是一个 GenericBeanDefinition 的对象用来承载数据
	if (beanDefinition instanceof AbstractBeanDefinition) {
		try {
			// 2、校验 beanDefinition
			((AbstractBeanDefinition) beanDefinition).validate();
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
					"Validation of bean definition failed", ex);
		}
	}
	// 3、这里定义一个 oldBeanDefinition 主要是 bean 是否可以覆盖,我们在同一个 Spring 配置文件中是不能定义
	// 两个相同 bean 的,但是可以在不同的配置文件中定义相同的 bean ,
	// Spring 默认 bean 可以覆盖,即如果存在两个相同名称的 bean ,后加载的那个 bean 覆盖先加载的 bean
	BeanDefinition oldBeanDefinition;
	
	// 4、通过 beanName 从 beanDefinitionMap 缓存中获取 beanDefinition
	oldBeanDefinition = this.beanDefinitionMap.get(beanName);
	// 5、如果已经存在了 beanDefinition
	if (oldBeanDefinition != null) {
		// 5.1、Spring 默认是可以 bean 覆盖的,但是如果设置了不可以进行 bean 覆盖,那么就抛出异常
		if (!isAllowBeanDefinitionOverriding()) {
			throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
					"Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
					"': There is already [" + oldBeanDefinition + "] bound.");
		}
		// 5.2、根据 Role 值进行判断,ROLE_APPLICATION=0 ROLE_SUPPORT=1 ROLE_INFRASTRUCTURE=2
		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 + "]");
			}
		}
		// 5.3、如果前后加载的两个 beanDefinition 内容不同 (这里的新、旧 beanDefinition 只是 beanName 相同)
		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 + "]");
			}
		}
		// 5.4、使用新加载的 beanDefinition 覆盖原先 beanDefinitionMap 缓存中的 oldBeanDefinition
		// {beanName:oldBeanDefinition} ----> {beanName:beanDefinition}
		this.beanDefinitionMap.put(beanName, beanDefinition);
	}
	// 6、如果 beanDefinitionMap 缓存中不存在 beanName
	else {
		// 7、如果创建 Bean 已经开始了
		if (hasBeanCreationStarted()) {
			// Cannot modify startup-time collection elements anymore (for stable iteration)
			// 7.1、加锁
			synchronized (this.beanDefinitionMap) {
				// 7.2、将本次传进来的 beanName 和 BeanDefinition 映射放入 beanDefinitionMap 缓存
				this.beanDefinitionMap.put(beanName, beanDefinition);
				// 7.3、将本次传进来的 beanName 加入beanDefinitionNames 缓存
				List<String> updatedDefinitions = new ArrayList<String>(this.beanDefinitionNames.size() + 1);
				updatedDefinitions.addAll(this.beanDefinitionNames);
				updatedDefinitions.add(beanName);
				this.beanDefinitionNames = updatedDefinitions;
				// 7.4、如果 manualSingletonNames 包含 beanName ,将 beanName 从 manualSingletonNames 移除
				if (this.manualSingletonNames.contains(beanName)) {
					Set<String> updatedSingletons = new LinkedHashSet<String>(this.manualSingletonNames);
					updatedSingletons.remove(beanName);
					this.manualSingletonNames = updatedSingletons;
				}
			}
		}
		// 8、目前在注册阶段,还没有到创建 bean 阶段,我们这里是初次启动项目,肯定没有创建 bean
		else {
			// Still in startup registration phase
			// 8.1、将 beanName beanDefinition 以键值对的形式存入 beanDefinitionMap 缓存中
			this.beanDefinitionMap.put(beanName, beanDefinition);
			// 8.2、将 beanName 存入 beanDefinitionNames 缓存中
			this.beanDefinitionNames.add(beanName);
			// 8.3、移除 manualSingletonNames 缓存中的 beanName
			this.manualSingletonNames.remove(beanName);
		}
		this.frozenBeanDefinitionNames = null;
	}
	// 9、如果存在相同 beanName 的 BeanDefinition，并且 beanName 已经存在单例对象,则将该 beanName 对应的缓存信息、单例对象清除，
    // 因为这些对象都是通过 oldBeanDefinition 创建出来的,需要使用新的 BeanDefinition 覆盖掉
    // 我们需要用新的 BeanDefinition(也就是本次传进来的 beanDefinition)来创建这些缓存和单例对象
	// (详情见代码块十)
	if (oldBeanDefinition != null || containsSingleton(beanName)) {
		resetBeanDefinition(beanName);
	}
}

代码块十、resetBeanDefinition(beanName)

// DefaultListableBeanFactory 类中的方法
protected void resetBeanDefinition(String beanName) {
    // Remove the merged bean definition for the given bean, if already created.
    // 1、删除 beanName 的 mergedBeanDefinitions 缓存(如果有的话)
    clearMergedBeanDefinition(beanName);
 
    // Remove corresponding bean from singleton cache, if any. Shouldn't usually
    // be necessary, rather just meant for overriding a context's default beans
    // (e.g. the default StaticMessageSource in a StaticApplicationContext).
    // 2、从单例缓存中删除该 beanName 对应的 bean(如果有的话)
    destroySingleton(beanName);
 
    // Reset all bean definitions that have the given bean as parent (recursively).
    // 3.重置 beanName 的所有子 Bean 定义(递归)
    for (String bdName : this.beanDefinitionNames) {
        if (!beanName.equals(bdName)) {
            BeanDefinition bd = this.beanDefinitionMap.get(bdName);
            // 当前遍历的 BeanDefinition 的 parentName 为 beanName,则递归调用 resetBeanDefinition 进行重置
            if (beanName.equals(bd.getParentName())) {
                resetBeanDefinition(bdName);
            }
        }
    }
}

代码块十一、resetBeanDefinition(bdName)

// SimpleAliasRegistry 类中的方法
public void registerAlias(String name, String alias) {
	Assert.hasText(name, "'name' must not be empty");
	Assert.hasText(alias, "'alias' must not be empty");
	// 1、如果 beanName 和别名相同,则 alias 无效,从 aliasMap 缓存中移除
	if (alias.equals(name)) {
		this.aliasMap.remove(alias);
	}
	else {
		// 2、通过 alias 从 aliasMap 缓存中获取 beanName 
		String registeredName = this.aliasMap.get(alias);
		if (registeredName != null) {
			// 3、校验通过 alias 获取到的 beanName 和传进来的 beanName 是否相等,如果相等,代表已经别名已经注册了,无需再注册
			if (registeredName.equals(name)) {
				// An existing alias - no need to re-register
				return;
			}
			// 4、如果不允许别名覆盖,则抛出异常
			if (!allowAliasOverriding()) {
				throw new IllegalStateException("Cannot register alias '" + alias + "' for name '" +
						name + "': It is already registered for name '" + registeredName + "'.");
			}
		}
		// 5、校验 name 和 alias 是否循环引用
		checkForAliasCircle(name, alias);
		// 6、将 alias beanName 的键值对存入 aliasMap 缓存中
		this.aliasMap.put(alias, name);
	}
}

到这里,一个 bean 标签的解析已经完成了,代码回到了这里

总结:

1、我们可以重新梳理一下思路,我们首先将 Spring 配置文件 xml 中的 bean 配置信息进行了解析,并构建了 AbstractBeanDefinition (GenericBeanDefinition ) 对象来存放所有解析出来的 bean 标签的所有属性和 bean 标签下面的子标签中的信息.

2、然后,我们将 AbstractBeanDefinition、beanName、aliasesArray 构建成 BeanDefinitionHolder 对象并返回.

3、最后,我们通过 BeanDefinitionHolder 将 BeanDefinition 和 beanName 注册到 BeanFactory 中，也就是存放到缓存中。

执行完 parseDefaultElement 方法，我们得到了两个重要的缓存：

beanDefinitionNames [beanName] 缓存

beanDefinitionMap {beanName:beanDefinition} 缓存

参考:https://blog.csdn.net/v123411739/article/details/86669952