发布日期: 2023-05-01

文章字数: 6.4k

阅读时长: 32 分

前言

Spring 容器加载方式

类路径获取配置文件

ApplicationContext applicationContext= new ClassPathXmlApplicationContext("spring.xml");

文件系统路径获取配置文件[绝对路径]

ApplicationContext applicationContext = new
FileSystemXmlApplicationContext("E:\\idea\\springdemo\\spring.xml");

无配置文件加载容器

ApplicationContext applicationContext = new
AnnotationConfigApplicationContext("com.xx.jack");

Spring Boot 加载容器

ApplicationContext applicationContext = new EmbeddedWebApplicationContext();

Spring 初始化核心流程

AbstractApplicationContext.refresh() 方法是 spring 容器启动过程中的核心方法，spring 容器要加载必须执行该方法。

public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			//为容器初始化做准备，重要程度：0
			// Prepare this context for refreshing.
			prepareRefresh();
			// 本章主要跟踪的内容
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			/*
			 * 给beanFactory设置一些属性值，可以不看
			 * */
			// Prepare the bean factory for use in this context.
			prepareBeanFactory(beanFactory);

			try {
				// Allows post-processing of the bean factory in context subclasses.
				postProcessBeanFactory(beanFactory);

				/*
				 * BeanDefinitionRegistryPostProcessor
				 * BeanFactoryPostProcessor
				 * 完成对这两个接口的调用
				 * */
				// Invoke factory processors registered as beans in the context.
				invokeBeanFactoryPostProcessors(beanFactory);

				/*
				 * 把实现了BeanPostProcessor接口的类实例化，并且加入到BeanFactory中
				 * */
				// Register bean processors that intercept bean creation.
				registerBeanPostProcessors(beanFactory);

				/*
				 * 国际化,重要程度2
				 * */
				// Initialize message source for this context.
				initMessageSource();

				//初始化事件管理类
				// Initialize event multicaster for this context.
				initApplicationEventMulticaster();

				//这个方法着重理解模板设计模式，因为在springboot中，这个方法是用来做内嵌tomcat启动的
				// Initialize other special beans in specific context subclasses.
				onRefresh();

				/*
				 * 往事件管理类中注册事件类
				 * */
				// Check for listener beans and register them.
				registerListeners();

				/*
				 * 这个方法是spring中最重要的方法，没有之一
				 * 所以这个方法一定要理解要具体看
				 * 1、bean实例化过程
				 * 2、ioc
				 * 3、注解支持
				 * 4、BeanPostProcessor的执行
				 * 5、Aop的入口
				 * */
				// Instantiate all remaining (non-lazy-init) singletons.
				finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
				finishRefresh();
			}

			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}

				// Destroy already created singletons to avoid dangling resources.
				destroyBeans();

				// Reset 'active' flag.
				cancelRefresh(ex);

				// Propagate exception to caller.
				throw ex;
			}

			finally {
				// Reset common introspection caches in Spring's core, since we
				// might not ever need metadata for singleton beans anymore...
				resetCommonCaches();
			}
		}
	}

本节主要跟进spring.xml核心配置类的解析过程，该流程主要包括：

创建BeanFactory对象
xml解析
封装成BeanDefinition对象

一、自定义标签解析

总结一下xml解析的主要流程：

根据当前解析的标签头信息，找到对应的namespaceUri
加载Spring所有jar中的META-INF/spring.handlers文件，并建立映射关系
根据namespaceUri从映射关系中找到对应的实现了NamespaceHandler接口的类
调用该类的init()方法，注册各种标签包括自定义标签的解析类
根据namespaceUri找到的对应的解析类，调用parse()方法完成标签的解析

二、Spring标签解析流程

先给出一个我自己画的时序图

"图1"

三、源码跟踪

入口

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

1.obtainFreshBeanFactory()

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
	//核心方法，必须读，重要程度：5
	//模板模式，子类实现钩子方法
	refreshBeanFactory();
	return getBeanFactory();
}

protected abstract void refreshBeanFactory() throws BeansException, IllegalStateException;

2.refreshBeanFactory()

refreshBeanFactory()实现类为AbstractRefreshableApplicationContext

protected final void refreshBeanFactory() throws BeansException {
	//1.如果BeanFactory不为空，则清除BeanFactory和里面的实例
	if (hasBeanFactory()) {
		destroyBeans();
		closeBeanFactory();
	}
	try {
		//2.创建BeanFactory实例工厂
		DefaultListableBeanFactory beanFactory = createBeanFactory();
		beanFactory.setSerializationId(getId());
		//3.1设置是否可以循环依赖 allowCircularReferences，默认允许
		//3.2是否允许使用相同名称重新注册不同的bean实现.
		customizeBeanFactory(beanFactory);
		//4.解析xml，并把xml中的标签封装成BeanDefinition对象
		loadBeanDefinitions(beanFactory);
		this.beanFactory = beanFactory;
	}
	catch (IOException ex) {
		throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
	}
}

注意
customizeBeanFactory(beanFactory)中关于设置是否循环依赖和是否可以覆盖bean定义名称，可以通过applicationContext上下文来修改，修改后必须要refresh()重新加载。建议不修改，没有意义。

applicationContext.setAllowBeanDefinitionOverriding(false);
applicationContext.setAllowCircularReferences(true);
applicationContext.refresh();

进入loadBeanDefinitions()方法

3.loadBeanDefinitions()

//AbstractXmlApplicationContext
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
	// Create a new XmlBeanDefinitionReader for the given BeanFactory.
	//创建xml的解析器，这里是一个委托模式
	XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

	// Configure the bean definition reader with this context's
	// resource loading environment.
	beanDefinitionReader.setEnvironment(this.getEnvironment());
	//这里传一个this进去，因为ApplicationContext是实现了ResourceLoader接口的
	beanDefinitionReader.setResourceLoader(this);
	beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

	// Allow a subclass to provide custom initialization of the reader,
	// then proceed with actually loading the bean definitions.
	initBeanDefinitionReader(beanDefinitionReader);
	//主要看这个方法  重要程度 5
	loadBeanDefinitions(beanDefinitionReader);
}

/**
* 委托给XmlBeanDefinitionReader解析xml文件
*/
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
	Resource[] configResources = getConfigResources();
	if (configResources != null) {
		reader.loadBeanDefinitions(configResources);
	}
	//获取需要加载的xml配置文件
	String[] configLocations = getConfigLocations();
	if (configLocations != null) {
		reader.loadBeanDefinitions(configLocations);
	}
}

进入AbstractBeanDefinitionReader.loadBeanDefinitions的重载方法

public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDefinitionStoreException {
	ResourceLoader resourceLoader = getResourceLoader();
	if (resourceLoader == null) {
		throw new BeanDefinitionStoreException(
				"Cannot load bean definitions from location [" + location + "]: no ResourceLoader available");
	}

	if (resourceLoader instanceof ResourcePatternResolver) {
		// Resource pattern matching available.
		try {
			//把字符串类型的xml文件路径，形如：classpath*:user/**/*-context.xml,转换成Resource对象类型，其实就是用流
			//的方式加载配置文件，然后封装成Resource对象，不重要，可以不看
			Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
			//主要看这个方法 ** 重要程度 5
			int count = loadBeanDefinitions(resources);
			if (actualResources != null) {
				Collections.addAll(actualResources, resources);
			}
			if (logger.isTraceEnabled()) {
				logger.trace("Loaded " + count + " bean definitions from location pattern [" + location + "]");
			}
			return count;
		}
		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 count = loadBeanDefinitions(resource);
		if (actualResources != null) {
			actualResources.add(resource);
		}
		if (logger.isTraceEnabled()) {
			logger.trace("Loaded " + count + " bean definitions from location [" + location + "]");
		}
		return count;
	}
}

然后进入

@Override
public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {
	Assert.notNull(resources, "Resource array must not be null");
	int count = 0;
	for (Resource resource : resources) {
		//模板设计模式，调用到子类中的方法
		count += loadBeanDefinitions(resource);
	}
	return count;
}

调用的是子类XmlBeanDefinitionReader的实现方法

@Override
public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
	//EncodedResource带编码的对Resource对象的封装
	return loadBeanDefinitions(new EncodedResource(resource));
}

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
	Assert.notNull(encodedResource, "EncodedResource must not be null");
	if (logger.isTraceEnabled()) {
		logger.trace("Loading XML bean definitions from " + encodedResource);
	}

	Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();

	if (!currentResources.add(encodedResource)) {
		throw new BeanDefinitionStoreException(
				"Detected cyclic loading of " + encodedResource + " - check your import definitions!");
	}

	//获取Resource对象中的xml文件流对象
	try (InputStream inputStream = encodedResource.getResource().getInputStream()) {

		//InputSource是jdk中的sax xml文件解析对象
		InputSource inputSource = new InputSource(inputStream);
		if (encodedResource.getEncoding() != null) {
			inputSource.setEncoding(encodedResource.getEncoding());
		}
		//主要看这个方法 **  重要程度 5
		return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
	}
	catch (IOException ex) {
		throw new BeanDefinitionStoreException(
				"IOException parsing XML document from " + encodedResource.getResource(), ex);
	}
	finally {
		currentResources.remove(encodedResource);
		if (currentResources.isEmpty()) {
			this.resourcesCurrentlyBeingLoaded.remove();
		}
	}
}

4.doLoadBeanDefinitions()

完成两个动作

把inputSource封装成Document文件对象

根据解析出来的document对象，拿到里面的标签元素封装成BeanDefinition

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
		throws BeanDefinitionStoreException {

	try {
		//把inputSource 封装成Document文件对象，这是jdk的API
		Document doc = doLoadDocument(inputSource, resource);

		//主要看这个方法，根据解析出来的document对象，拿到里面的标签元素封装成BeanDefinition
		int count = registerBeanDefinitions(doc, resource);
		if (logger.isDebugEnabled()) {
			logger.debug("Loaded " + count + " bean definitions from " + resource);
		}
		return count;
	}
	catch (BeanDefinitionStoreException ex) {
		throw ex;
	}
	catch (SAXParseException ex) {
		throw new XmlBeanDefinitionStoreException(resource.getDescription(),
				"Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);
	}
	catch (SAXException ex) {
		throw new XmlBeanDefinitionStoreException(resource.getDescription(),
				"XML document from " + resource + " is invalid", ex);
	}
	catch (ParserConfigurationException ex) {
		throw new BeanDefinitionStoreException(resource.getDescription(),
				"Parser configuration exception parsing XML from " + resource, ex);
	}
	catch (IOException ex) {
		throw new BeanDefinitionStoreException(resource.getDescription(),
				"IOException parsing XML document from " + resource, ex);
	}
	catch (Throwable ex) {
		throw new BeanDefinitionStoreException(resource.getDescription(),
				"Unexpected exception parsing XML document from " + resource, ex);
	}
}

5.registerBeanDefinitions()

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
	//又来一记委托模式，BeanDefinitionDocumentReader委托这个类进行document的解析
	BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
	int countBefore = getRegistry().getBeanDefinitionCount();

	//主要看这个方法，createReaderContext(resource) XmlReaderContext上下文，封装了XmlBeanDefinitionReader对象
	documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
	return getRegistry().getBeanDefinitionCount() - countBefore;
}

交由DefaultBeanDefinitionDocumentReader.registerBeanDefinitions()处理

public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
	this.readerContext = readerContext;
	//主要看这个方法，把root节点传进去
	doRegisterBeanDefinitions(doc.getDocumentElement());
}

protected void doRegisterBeanDefinitions(Element root) {
	BeanDefinitionParserDelegate parent = this.delegate;
	this.delegate = createDelegate(getReaderContext(), root, parent);
	if (this.delegate.isDefaultNamespace(root)) {
		String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
		if (StringUtils.hasText(profileSpec)) {
			String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
					profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
			// We cannot use Profiles.of(...) since profile expressions are not supported
			// in XML config. See SPR-12458 for details.
			if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
				if (logger.isDebugEnabled()) {
					logger.debug("Skipped XML bean definition file due to specified profiles [" + profileSpec +
							"] not matching: " + getReaderContext().getResource());
				}
				return;
			}
		}
	}
	preProcessXml(root);
	//主要看这个方法，标签具体解析过程
	parseBeanDefinitions(root, this.delegate);
	postProcessXml(root);
	this.delegate = parent;
}

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);
	}
}

可以看出有两种解析的类型：

Spring默认标签
自定义标签

我们先看默认标签是怎么解析的。

6.parseDefaultElement()

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
	//import标签解析  重要程度 1 ，可看可不看
	if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
		importBeanDefinitionResource(ele);
	}
	//alias标签解析 别名标签  重要程度 1 ，可看可不看
	else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
		processAliasRegistration(ele);
	}
	//bean标签，重要程度  5，必须看
	else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
		processBeanDefinition(ele, delegate);
	}
	else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
		// recurse
		doRegisterBeanDefinitions(ele);
	}
}

默认标签主要解析

import
alias
bean
beans

这里我主要跟踪bean标签的解析过程：

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
	//重点看这个方法，重要程度 5 ，解析document，封装成BeanDefinition
	BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
	if (bdHolder != null) {
		//该方法功能不重要，设计模式重点看一下，装饰者设计模式，加上SPI设计思想
		bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
		try {
			//完成document到BeanDefinition对象转换后，对BeanDefinition对象进行缓存注册
			// 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));
	}
}

BeanDefinitionHolder这个类有两个很重要的属性：beanDefinition和beanName

public class BeanDefinitionHolder implements BeanMetadataElement {
	private final BeanDefinition beanDefinition;
	private final String beanName;
	//aliases作用：通过aliases找到beanName，根据beanName拿到beanDefinition对象。
	private final String[] aliases;
	......
}

/**
* BeanDefinitionParserDelegate
* Description: 解析Element并返回 BeanDefinitionHolder
*/
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
		String id = ele.getAttribute(ID_ATTRIBUTE);
		String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
		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.isTraceEnabled()) {
				logger.trace("No XML 'id' specified - using '" + beanName +
						"' as bean name and " + aliases + " as aliases");
			}
		}
		// 检查 beanName 是否重复
		if (containingBean == null) {
			checkNameUniqueness(beanName, aliases, ele);
		}
		// 重点，解析BeanDefinitionElement
		AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
		// 此处省略没用的代码
		......
		String[] aliasesArray = StringUtils.toStringArray(aliases);
			return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
}

进入BeanDefinitionParserDelegate.parseBeanDefinitionElement()方法

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 {
		//创建GenericBeanDefinition对象
		AbstractBeanDefinition bd = createBeanDefinition(className, parent);
		//解析bean标签的属性，并把解析出来的属性设置到BeanDefinition对象中
		parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
		bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
		//解析bean中的meta标签
		parseMetaElements(ele, bd);
		//解析bean中的lookup-method标签  重要程度：2，可看可不看
		parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
		//解析bean中的replaced-method标签  重要程度：2，可看可不看
		parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
		//解析bean中的constructor-arg标签  重要程度：2，可看可不看
		parseConstructorArgElements(ele, bd);
		//解析bean中的property标签  重要程度：2，可看可不看
		parsePropertyElements(ele, bd);
		//可以不看，用不到
		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;
}

其中，

parseBeanDefinitionAttributes：负责解析<bean>属性，形如：

<bean class="com.enjoy.jack.bean.Student" 
	id="student2" 
	p:username="1234" 
	factory-bean="" 
	factory-method="" 
	init-method="" 
	abstract="true" 
	parent="" 
	lazy-init="true" 
	primary="true"
/>

parseMetaElements：负责解析bean标签下的<meta>标签，形如：

<bean class="com.enjoy.jack.bean.Student" id="student2" p:username="1234" factory-bean="" factory-method="" init-method="" abstract="true" parent="" lazy-init="true" primary="true">
    <description>这个是student</description>
    <meta key="name1" value="Jack"/>
    <meta key="name2" value="Dafei"/>
</bean>

parseLookupOverrideSubElements：负责解析<lookup-method>，形如：

<bean id="people" class="com.enjoy.jack.bean.ShowSixClass">
    <lookup-method name="getPeople" bean="woman"></lookup-method>
</bean>

parseReplacedMethodSubElements：负责解析<replaced-method>，形如：

<bean id="originClass" class="com.enjoy.jack.bean.OriginClass">
    <replaced-method name="method" replacer="repalceClass">
        <arg-type match="java.lang.String"/>
    </replaced-method>
</bean>

parseConstructorArgElements：负责解析<constructor-arg>，形如：

<bean class="com.enjoy.jack.bean.ConstructorArgBean" id="constructorArgBean">
    <constructor-arg name="username" value="Jack" index="0" type="java.lang.String"/>
    <constructor-arg name="password" value="123" index="1" type="java.lang.String"/>
</bean>

parsePropertyElements：负责解析<property>，形如：

<bean class="com.enjoy.jack.bean.PropertyBean" id="propertyBean">
   <property name="username" value="Jack"/>
   <property name="password" value="123"/>
</bean>

另外，注意这几点：

<bean>标签解析完成，会统一放到BeanDefinition中。
<lookup-method>、<replaced-method>、<property>这种子标签会放到MutablePropertyValues 类中。

<constructor-arg>子标签会放到 ConstructorArgumentValues 类中。
后面两点可以在processBeanDefinition()方法中，在完成bean标签解析完后的装饰方法

bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);

可以追溯到。这里不做跟踪。我这里重点看看<bean>标签的解析方法parseBeanDefinitionAttributes():

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

	if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {
		error("Old 1.x 'singleton' attribute in use - upgrade to 'scope' declaration", ele);
	}
	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());
	}

	if (ele.hasAttribute(ABSTRACT_ATTRIBUTE)) {
		bd.setAbstract(TRUE_VALUE.equals(ele.getAttribute(ABSTRACT_ATTRIBUTE)));
	}

	String lazyInit = ele.getAttribute(LAZY_INIT_ATTRIBUTE);
	if (isDefaultValue(lazyInit)) {
		lazyInit = this.defaults.getLazyInit();
	}
	bd.setLazyInit(TRUE_VALUE.equals(lazyInit));

	String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);
	bd.setAutowireMode(getAutowireMode(autowire));

	if (ele.hasAttribute(DEPENDS_ON_ATTRIBUTE)) {
		String dependsOn = ele.getAttribute(DEPENDS_ON_ATTRIBUTE);
		bd.setDependsOn(StringUtils.tokenizeToStringArray(dependsOn, MULTI_VALUE_ATTRIBUTE_DELIMITERS));
	}

	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));
	}

	if (ele.hasAttribute(PRIMARY_ATTRIBUTE)) {
		bd.setPrimary(TRUE_VALUE.equals(ele.getAttribute(PRIMARY_ATTRIBUTE)));
	}

	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);
	}

	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);
	}

	if (ele.hasAttribute(FACTORY_METHOD_ATTRIBUTE)) {
		bd.setFactoryMethodName(ele.getAttribute(FACTORY_METHOD_ATTRIBUTE));
	}
	if (ele.hasAttribute(FACTORY_BEAN_ATTRIBUTE)) {
		bd.setFactoryBeanName(ele.getAttribute(FACTORY_BEAN_ATTRIBUTE));
	}

	return bd;
}

可以对应上xml:

<bean class="com.enjoy.jack.bean.Student" 
	id="student2" 
	p:username="1234" 
	factory-bean="" 
	factory-method="" 
	init-method="" 
	abstract="true" 
	parent="" 
	lazy-init="true" 
	primary="true"
/>

<bean>标签解析过程的代码跟踪到这里，回到DefaultBeanDefinitionDocumentReader的 processBeanDefinition() 方法继续往下走，第一步已经对BeanDefinition属性解析完成，返回 BeanDefinitionHolder 对象。第二步装饰的过程这里不跟了。接下来跟下注册 registerBeanDefinition的过程（第三步）。

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
	//1.重点看这个方法，重要程度 5 ，解析document，封装成BeanDefinition
	BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
	if (bdHolder != null) {
		//2.该方法功能不重要，设计模式重点看一下，装饰者设计模式，加上SPI设计思想
		bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
		try {
			//3.完成document到BeanDefinition对象转换后，对BeanDefinition对象进行缓存注册
			// 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);
		}
		// 4.Send registration event.
		getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
	}
}

调用的是工具类BeanDefinitionReaderUtils的方法registerBeanDefinition()：

public static void registerBeanDefinition(
		BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
		throws BeanDefinitionStoreException {
	// Register bean definition under primary name.
	String beanName = definitionHolder.getBeanName();
	//完成BeanDefinition的注册，重点看，重要程度 5
	registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
	//建立别名和 id的映射，这样就可以根据别名获取到id
	// Register aliases for bean name, if any.
	String[] aliases = definitionHolder.getAliases();
	if (aliases != null) {
		for (String alias : aliases) {
			registry.registerAlias(beanName, alias);
		}
	}
}

DefaultListableBeanFactory.registerBeanDefinition()方法，最终完成默认标签的注册。

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 {
			((AbstractBeanDefinition) beanDefinition).validate();
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
					"Validation of bean definition failed", ex);
		}
	}
	//先判断BeanDefinition是否已经注册
	BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
	if (existingDefinition != null) {
		if (!isAllowBeanDefinitionOverriding()) {
			throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
		}
		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 + "]");
			}
		}
		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 {
			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 {
		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 {
			//把beanDefinition缓存到map中
			// Still in startup registration phase
			this.beanDefinitionMap.put(beanName, beanDefinition);
			//把beanName放到beanDefinitionNames list中，这个list着重记住，bean实例化的时候需要用到
			this.beanDefinitionNames.add(beanName);
			removeManualSingletonName(beanName);
		}
		this.frozenBeanDefinitionNames = null;
	}

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

总结下DefaultListableBeanFactory.registerBeanDefinition()方法的功能：

把bean名称和beanDefinition放到 Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256)的容器中
把bean名称放到ListbeanDefinitionNames = new ArrayList<>(256) 的 list容器中缓存起来

bean的实例化过程中会用到这两个东东。
到这儿，Spring默认标签解析完成代码追踪了，接下来跟跟自定义标签的解析过程。

7.parseCustomElement()

调用流程还是和目录一中描述的一样。Talk is cheap, show me the code.

/**
* BeanDefinitionParserDelegate
* Description: 自定义标签交给BeanDefinitionParserDelegate 委托类来解析
*/
public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
	// 获取命名空间的URI
	String namespaceUri = getNamespaceURI(ele);
	if (namespaceUri == null) {
		return null;
	}
	// SPI设计，获取/META-INF/spring.handers中URI对应的Hander处理类
	//具体解析内容如下：
	//获取spring中所有jar包里面的META-INF/spring.handlers文件，并且建立映射关系。
	//根据namespaceUri获取到这个命名空间的处理类。
	//调用处理类的init()方法，在init()方法中完成标签元素解析类的注册。
	NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
	if (handler == null) {
		error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
		return null;
	}
	// 执行 实现类NamespaceHandlerSupport 中的parse 方法
	return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
}

先看看resolve方法

public NamespaceHandler resolve(String namespaceUri) {
	//获取spring中所有jar包里面的 "META-INF/spring.handlers"文件，并且建立映射关系
	Map<String, Object> handlerMappings = getHandlerMappings();
	//根据namespaceUri：http://www.springframework.org/schema/context，获取到这个命名空间的处理类
	Object handlerOrClassName = handlerMappings.get(namespaceUri);
	if (handlerOrClassName == null) {
		return null;
	}
	else if (handlerOrClassName instanceof NamespaceHandler) {
		return (NamespaceHandler) handlerOrClassName;
	}
	else {
		String className = (String) handlerOrClassName;
		try {
			Class<?> handlerClass = ClassUtils.forName(className, this.classLoader);
			if (!NamespaceHandler.class.isAssignableFrom(handlerClass)) {
				throw new FatalBeanException("Class [" + className + "] for namespace [" + namespaceUri +
						"] does not implement the [" + NamespaceHandler.class.getName() + "] interface");
			}
			NamespaceHandler namespaceHandler = (NamespaceHandler) BeanUtils.instantiateClass(handlerClass);

			//调用处理类的init方法，在init方法中完成标签元素解析类的注册
			namespaceHandler.init();
			handlerMappings.put(namespaceUri, namespaceHandler);
			return namespaceHandler;
		}
		catch (ClassNotFoundException ex) {
			throw new FatalBeanException("Could not find NamespaceHandler class [" + className +
					"] for namespace [" + namespaceUri + "]", ex);
		}
		catch (LinkageError err) {
			throw new FatalBeanException("Unresolvable class definition for NamespaceHandler class [" +
					className + "] for namespace [" + namespaceUri + "]", err);
		}
	}
}

这个方法很重要，总结下它的功能：

获取spring中所有jar包里面的 “META-INF/spring.handlers”文件，并且建立映射关系至handlerMappings
根据namespaceUri：http://www.springframework.org/schema/context，获取到这个命名空间的处理类
反射实例化它对应的NamespaceHandler
调用处理类NamespaceHandler的init方法，在init方法中完成标签元素解析类的注册
注册这个NamespaceHandler至handlerMappings

进入parse方法

/**
* NamespaceHandlerSupport
* Description: 委托BeanDefinitionParser类解析元素
*/
public BeanDefinition parse(Element element, ParserContext parserContext) {
	// 获取自定义组件名 对应的解析方法
	BeanDefinitionParser parser = findParserForElement(element, parserContext);
	// 调用ComponentScanBeanDefinitionParser实现类中的 parse方法
	return (parser != null ? parser.parse(element, parserContext) : null);
}

进入findParserForElement()方法

/**
* NamespaceHandlerSupport
* Description: 从map中根据组件名称获取绑定的解析方法
*/
private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {
	// 获取组件名称
	String localName = parserContext.getDelegate().getLocalName(element);
	// Map<String, BeanDefinitionParser> parsers = new HashMap<>()
	//此处this.parsers.get()之所以有值，是因为在/META-INF/spring.handers中URI对应的Hander处理类初始化的时候，通过init()方法中,执行registerBeanDefinitionParser()，来调用this.parsers.set('标签元素','解析类')设置的。
	BeanDefinitionParser parser = this.parsers.get(localName);
	if (parser == null) {
		parserContext.getReaderContext().fatal(
				"Cannot locate BeanDefinitionParser for element [" + localName + "]", element);
	}
	return parser;
}

这里我们以<component-scan>标签为例
先看看它所在的NamespaceHandler配置在哪儿

http\://www.springframework.org/schema/context=org.springframework.context.config.ContextNamespaceHandler

对应的java文件

public class ContextNamespaceHandler extends NamespaceHandlerSupport {

	@Override
	public void init() {
		registerBeanDefinitionParser("property-placeholder", new PropertyPlaceholderBeanDefinitionParser());
		registerBeanDefinitionParser("property-override", new PropertyOverrideBeanDefinitionParser());
		registerBeanDefinitionParser("annotation-config", new AnnotationConfigBeanDefinitionParser());
		registerBeanDefinitionParser("component-scan", new ComponentScanBeanDefinitionParser());
		registerBeanDefinitionParser("load-time-weaver", new LoadTimeWeaverBeanDefinitionParser());
		registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
		registerBeanDefinitionParser("mbean-export", new MBeanExportBeanDefinitionParser());
		registerBeanDefinitionParser("mbean-server", new MBeanServerBeanDefinitionParser());
	}

}

完成这些标签解析类的注册后，返回到方法中

/**
* BeanDefinitionParserDelegate
* Description: 自定义标签交给BeanDefinitionParserDelegate 委托类来解析
*/
public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
	// 获取命名空间的URI
	String namespaceUri = getNamespaceURI(ele);
	if (namespaceUri == null) {
		return null;
	}
	// SPI设计，获取/META-INF/spring.handers中URI对应的Hander处理类
	//具体解析内容如下：
	//获取spring中所有jar包里面的META-INF/spring.handlers文件，并且建立映射关系。
	//根据namespaceUri获取到这个命名空间的处理类。
	//调用处理类的init()方法，在init()方法中完成标签元素解析类的注册。
	NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
	if (handler == null) {
		error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
		return null;
	}
	// 执行 实现类NamespaceHandlerSupport 中的parse 方法
	return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
}

看看ComponentScanBeanDefinitionParser.parse解析过程

/** Description: 核心解析
 * 1、扫描路径.class后缀的文件
 * 2、要判断类上是否有注解
 * 3、GenericBeanDefinition genericBeanDefinition = new GenericBeanDefinition();
 *    genericBeanDefinition.setBeanClass(BeanClass.class);
 * 4、完成beanDefinition注册
 * */
public BeanDefinition parse(Element element, ParserContext parserContext) {
	//获取basePackage属性
	String basePackage = element.getAttribute(BASE_PACKAGE_ATTRIBUTE);
	basePackage = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(basePackage);
	//可以用逗号分开
	String[] basePackages = StringUtils.tokenizeToStringArray(basePackage,
			ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
	//创建注解扫描器
	// Actually scan for bean definitions and register them.
	ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);
	//扫描并把扫描的类封装成beanDefinition对象  核心方法，重要程度 5
	Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);
	registerComponents(parserContext.getReaderContext(), beanDefinitions, element);
	return null;
}

获取basePackage这里不做跟踪了，先看看创建扫描器的过程

//创建注解扫描器
// Actually scan for bean definitions and register them.
ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);

点进去看看

protected ClassPathBeanDefinitionScanner configureScanner(ParserContext parserContext, Element element) {
	//使用默认的过滤器
	boolean useDefaultFilters = true;
	if (element.hasAttribute(USE_DEFAULT_FILTERS_ATTRIBUTE)) {
		useDefaultFilters = Boolean.parseBoolean(element.getAttribute(USE_DEFAULT_FILTERS_ATTRIBUTE));
	}
	//重点看看这里的创建
	// Delegate bean definition registration to scanner class.
	ClassPathBeanDefinitionScanner scanner = createScanner(parserContext.getReaderContext(), useDefaultFilters);
	scanner.setBeanDefinitionDefaults(parserContext.getDelegate().getBeanDefinitionDefaults());
	scanner.setAutowireCandidatePatterns(parserContext.getDelegate().getAutowireCandidatePatterns());
	if (element.hasAttribute(RESOURCE_PATTERN_ATTRIBUTE)) {
		scanner.setResourcePattern(element.getAttribute(RESOURCE_PATTERN_ATTRIBUTE));
	}
	try {
		// 解析子标签，不用看
		parseBeanNameGenerator(element, scanner);
	}
	catch (Exception ex) {
		parserContext.getReaderContext().error(ex.getMessage(), parserContext.extractSource(element), ex.getCause());
	}
	try {
		// 解析子标签，不用看
		parseScope(element, scanner);
	}
	catch (Exception ex) {
		parserContext.getReaderContext().error(ex.getMessage(), parserContext.extractSource(element), ex.getCause());
	}
	// 会扫描含有"include-filter"和"exclude-filter"属性进行解析
	parseTypeFilters(element, scanner, parserContext);
	return scanner;
}

再点进去看看createScanner()方法

protected ClassPathBeanDefinitionScanner createScanner(XmlReaderContext readerContext, boolean useDefaultFilters) {
	return new ClassPathBeanDefinitionScanner(readerContext.getRegistry(), useDefaultFilters,
			readerContext.getEnvironment(), readerContext.getResourceLoader());
}

public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
		Environment environment, @Nullable ResourceLoader resourceLoader) {
	Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
	this.registry = registry;
	//使用默认的过滤器，扫描带有@Component注解的类
	if (useDefaultFilters) {
		registerDefaultFilters();
	}
	setEnvironment(environment);
	setResourceLoader(resourceLoader);
}
/**
 *  Description: 使用默认过滤规则 处理指定的注解类，然后注册
 * 扫描对象为带有以下注解的类：
 * @Component
 * @Controller
 * @Service
 * @Repository
 * 以及Java EE 6的javax.annotation.ManagedBean,JSR-330的javax.inject.Named的注解
 */
protected void registerDefaultFilters() {
	// 过滤器中添加需要扫描的注解类型
	// 将注解添加到 AnnotationTypeFilter包装类
	this.includeFilters.add(new AnnotationTypeFilter(Component.class));
	// 确保类注解是 ClassPathScanningCandidateComponentProvider的类加载器
	ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
	try {
		this.includeFilters.add(new AnnotationTypeFilter(
				((Class<? extends Annotation>) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false));
		logger.trace("JSR-250 'javax.annotation.ManagedBean' found and supported for component scanning");
	}
	catch (ClassNotFoundException ex) {
		// JSR-250 1.1 API (as included in Java EE 6) not available - simply skip.
	}
	try {
		this.includeFilters.add(new AnnotationTypeFilter(
				((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Named", cl)), false));
		logger.trace("JSR-330 'javax.inject.Named' annotation found and supported for component scanning");
	}
	catch (ClassNotFoundException ex) {
		// JSR-330 API not available - simply skip.
	}
}

将拦截到的注解添加到List<TypeFilter> includeFilters = new LinkedList<>() 容器中。
创建注解扫描器完毕，返回到parse()方法中，跟下doScan()过程。

protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
	Assert.notEmpty(basePackages, "At least one base package must be specified");
	Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
	for (String basePackage : basePackages) {
		//扫描到有注解的类并封装成BeanDefinition对象
		Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
		for (BeanDefinition candidate : candidates) {
			ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
			candidate.setScope(scopeMetadata.getScopeName());
			String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
			if (candidate instanceof AbstractBeanDefinition) {
				//支持了@Lazy @DependOn注解
				postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
			}
			if (candidate instanceof AnnotatedBeanDefinition) {
				AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
			}
			if (checkCandidate(beanName, candidate)) {
				BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
				definitionHolder =
						AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
				beanDefinitions.add(definitionHolder);
				//BeanDefinition注册
				registerBeanDefinition(definitionHolder, this.registry);
			}
		}
	}
	return beanDefinitions;
}

点进去看看registerBeanDefinition()方法

protected void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) {
	BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, registry);
}

/**
* BeanDefinitionReaderUtils
* Description : 向指定的bean工厂注册BeanDefinition
*/
public static void registerBeanDefinition(
		BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
		throws BeanDefinitionStoreException {
	// Register bean definition under primary name.
	String beanName = definitionHolder.getBeanName();
	//完成BeanDefinition的注册，重点看，重要程度 5
	registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
	//建立别名和 id的映射，这样就可以根据别名获取到id
	// Register aliases for bean name, if any.
	String[] aliases = definitionHolder.getAliases();
	if (aliases != null) {
		for (String alias : aliases) {
			registry.registerAlias(beanName, alias);
		}
	}
}

/**
* DefaultListableBeanFactory
* Description: 自定义标签的注册，和默认标签的注册方式一致，两个map
*/
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 {
			((AbstractBeanDefinition) beanDefinition).validate();
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
					"Validation of bean definition failed", ex);
		}
	}
	// 先判断 BeanDefinition是否已经注册
	BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
	if (existingDefinition != null) {
		if (!isAllowBeanDefinitionOverriding()) {
			throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
		}
		// ...... 省略 ......
		else {
			// 把 beanDefinition 缓存到map中
			this.beanDefinitionMap.put(beanName, beanDefinition);
			//把 beanName放到 beanDefinitionNames list中，bean实例化的时候需要用到
			this.beanDefinitionNames.add(beanName);
			this.manualSingletonNames.remove(beanName);
		}
		this.frozenBeanDefinitionNames = null;
	}
	if (existingDefinition != null || containsSingleton(beanName)) {
		resetBeanDefinition(beanName);
	}
}