Spring源码深度解析：四、Spring配置文件加载流程

代码的知行者

已于 2022-12-06 11:22:44 修改

阅读量2.4k

点赞数 2

分类专栏：源码 Spring 文章标签： spring java 后端

于 2022-10-30 23:02:30 首次发布

本文链接：https://blog.csdn.net/wts563540/article/details/127592624

版权

Spring 同时被 2 个专栏收录

29 篇文章 9 订阅

订阅专栏

源码

22 篇文章 5 订阅

订阅专栏

一、前言

文章目录：Spring源码深度解析：文章目录

我们先通过Spring配置文件加载流程图，来了解Spring配置文件加载流程，接着根据这个工作流程一步一步的阅读源码
主要加载xml配置文件的属性值到当前工厂中，最重要的就是BeanDefinition。
在这里插入图片描述

二、配置文件加载入口 - obtainFreshBeanFactory()

AbstractApplicationContext#obtainFreshBeanFactory()
首先Spring容器的启动我们debug进入的是Spring的容器刷新方法：refresh()，接着我们F7进入子方法obtainFreshBeanFactory()该方法先创建容器对象：DefaultListableBeanFactory，然后加载xml配置文件的属性值到当前工厂中，最重要的就是BeanDefinition。具体代码如下：

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
		// 创建BeanFactory：判断是否存在bean工厂，如果存在就进行销毁；再重新实例化一个bean工厂。
		refreshBeanFactory();
		// 再调用AbstractRefreshableApplicationContext的getBeanFactory()方法获取在refresh()创建的bean工厂
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		// 如果获取到的bean工厂是空，会抛出异常。
		if (logger.isDebugEnabled()) {
			logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
		}
		return beanFactory;
	}

obtainFreshBeanFactory() >>> AbstractApplicationContext#refreshBeanFactory()
再进入刷新BeanFactory的方法：refreshBeanFactory() 具体代码如下：

protected final void refreshBeanFactory() throws BeansException {
		// 如果存在beanFactory,则销毁beanFactory
		if (hasBeanFactory()) {
			destroyBeans();
			closeBeanFactory();
		}
		try {
			// 创建DefaultListableBeanFactory对象
			DefaultListableBeanFactory beanFactory = createBeanFactory();
			// 为了序列化指定id,可以从id反序列化到beanFactory对象
			beanFactory.setSerializationId(getId());
			// 定制beanFactory,设置相关属性，包括是否允许覆盖同名称的不同定义的对象以及循环依赖
			customizeBeanFactory(beanFactory);
			// 初始化documentReader,并进行XML文件读取及解析
			loadBeanDefinitions(beanFactory);
			this.beanFactory = beanFactory;
		}
		catch (IOException ex) {
			throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
		}
	}

三、XML文件读取及解析 - loadBeanDefinitions()

概览

refreshBeanFactory() >>> AbstractXmlApplicationContext#loadBeanDefinitions()
loadBeanDefinitions():方法就是初始化documentReader,并进行XML文件读取及解析，从这一步Spring开始它的配置文件加载流程。
具体代码如下：

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
		// 创建一个xml的beanDefinitionReader,并通过回调设置到beanFactory中
		XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
		// 给reader对象设置环境变量
		beanDefinitionReader.setEnvironment(this.getEnvironment());
		// 设置资源加载器
		beanDefinitionReader.setResourceLoader(this);
		// 设置实体处理器
		beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
		// 初始化beanDefinitionReader对象，此处设置配置文件是否要进行验证[使用的适配器模式]
		initBeanDefinitionReader(beanDefinitionReader);
		// 开始完成beanDefinition的加载
		loadBeanDefinitions(beanDefinitionReader);
	}

下面简单概括一下上面的初始化documentReader,并进行XML文件读取及解析的步骤

XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory); ：创建一个xml的beanDefinitionReader,并通过回调设置到beanFactory中
beanDefinitionReader.setEnvironment(this.getEnvironment());：给reader对象设置环境变量，便于配置文件里的占位符替换需要的值
beanDefinitionReader.setResourceLoader(this);：设置资源加载器
beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));：设置实体处理器，当我们真正解析xml的时候才会使用它。
initBeanDefinitionReader(beanDefinitionReader);：初始化beanDefinitionReader对象，此处设置配置文件是否要进行验证[使用的适配器模式]
loadBeanDefinitions(beanDefinitionReader);：开始完成beanDefinition的加载重点、重点、重点

下面我们来分析每一步的具体内容。

详述

1、设置实体处理器 - beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));作用就是设置实体处理器（这里仅仅是设置），我们把xml当作一个对象，里面会有很多属性，当我们真正解析xml的时候才会使用它。
loadBeanDefinitions() >>> ResourceEntityResolver#ResourceEntityResolver(）
我们进入new ResourceEntityResolver(this)构造方法
具体代码如下：

public ResourceEntityResolver(ResourceLoader resourceLoader) {
		super(resourceLoader.getClassLoader());
		this.resourceLoader = resourceLoader;
	}

接着我们进入super方法，具体代码如下：

DelegatingEntityResolver#DelegatingEntityResolver()

	public DelegatingEntityResolver(@Nullable ClassLoader classLoader) {
		this.dtdResolver = new BeansDtdResolver();
		// 当完成这行代码的调用之后，大家神奇的发现一件事情，schemeResolver对象的schemeMappings属性被完成了赋值操作，但是你遍历完成所有代码后依然没有看到显式调用
		// 其实此时的原理是非常简单的，我们在进行debug的时候，因为在程序运行期间需要显示当前类的所有信息，所以idea会帮助我们调用toString方法，只不过此过程我们识别不到而已
		this.schemaResolver = new PluggableSchemaResolver(classLoader);
	}

此方法初始化两种配置文件的属性，1、如果我们是dtd配置文件，会使用new BeansDtdResolver()来解析；2、如果我们是xsd配置文件，我们会调用new PluggableSchemaResolver(classLoader);构造方法,现在我们基本上都是使用xsd配置方式，现在我们进入new PluggableSchemaResolver(classLoader);构造方法。代码如下：

PluggableSchemaResolver#PluggableSchemaResolver()

public PluggableSchemaResolver(@Nullable ClassLoader classLoader) {
		this.classLoader = classLoader;
		this.schemaMappingsLocation = DEFAULT_SCHEMA_MAPPINGS_LOCATION;
	}

	public static final String DEFAULT_SCHEMA_MAPPINGS_LOCATION = "META-INF/spring.schemas";

我们发现构造方法什么都没干，但是它指出了一个关键路径，spring会先读取这个路径下的文件，我们会知道xsd文件会映射到哪个目录下。此时我们解析的时候，不需要从网上下载资源去解析配置文件在这里插入图片描述
，我们拿到之后找到本地映射的地方进行解析，所以联网不联网我们都可以解析xsd文件

当完成这行代码this.schemaResolver = new PluggableSchemaResolver(classLoader);的调用之后，大家神奇的发现一件事情，schemeResolver对象的schemeMappings属性被完成了赋值操作，但是你遍历完成所有代码后依然没有看到显式调用。其实此时的原理是非常简单的，我们在进行debug的时候，因为在程序运行期间需要显示当前类的所有信息，所以idea会帮助我们调用toString方法，只不过此过程我们识别不到而已
PluggableSchemaResolver#toString()

public String toString() {
		return "EntityResolver using schema mappings " + getSchemaMappings();
	}

PluggableSchemaResolver#getSchemaMappings()
PropertiesLoaderUtils.loadAllProperties(this.schemaMappingsLocation, this.classLoader);该方法就是加载META-INF/spring.schemas
在这里插入图片描述

2、初始化beanDefinitionReader对象 - initBeanDefinitionReader(beanDefinitionReader);

loadBeanDefinitions() >>> AbstractXmlApplicationContext#initBeanDefinitionReader()

protected void initBeanDefinitionReader(XmlBeanDefinitionReader reader) {
		reader.setValidating(this.validating);
	}

在这里插入图片描述

3、开始完成beanDefinition的加载 - loadBeanDefinitions(beanDefinitionReader);

loadBeanDefinitions() >>> AbstractXmlApplicationContext#loadBeanDefinitions(XmlBeanDefinitionReader reader)

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
		// 以Resource的方式获取配置文件的资源位置
		Resource[] configResources = getConfigResources();
		if (configResources != null) {
			reader.loadBeanDefinitions(configResources);
		}
		// 以String的形式获得配置文件的位置
		String[] configLocations = getConfigLocations();
		if (configLocations != null) {
			reader.loadBeanDefinitions(configLocations);
		}
	}

我们可以看出该方法主要是获取配置文件的位置，总共有两种方式获取配置文件的位置：1)、以Resource的方式获取配置文件的资源位置；2)、以String的形式获得配置文件的位置。根据我们的自己debug的方式可以看出我们是以String的形式获取破欸之文件的位置。该获取方式包含两个方法，我们来一个个的看一下：

getConfigLocations()方法
看到 getConfigLocations()方法我们要想到spring容器启动的时候刚开始进来有一个设置配置路径的方法，和我们这边的方法相互呼应

我们来看一下AbstractRefreshableConfigApplicationContext类里面的一些getter和setter方法
1. setConfigLocations()
2. getConfigLocations()
  
  可以看到我们getConfigLocations()获取到的返回值正是我们set进去的值
reader.loadBeanDefinitions(configLocations)方法
接下来我们分析reader.loadBeanDefinitions(configLocations);
AbstractXmlApplicationContext#loadBeanDefinitions(beanDefinitionReader) >>> AbstractXmlApplicationContext#loadBeanDefinitions(String… locations)

@Override
	public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException {
		Assert.notNull(locations, "Location array must not be null");
		int counter = 0;
		for (String location : locations) {
			counter += loadBeanDefinitions(location);
		}
		return counter;
	}

我们可以看到该方法循环String数组，开始处理每一个单一的location，我们在进入loadBeanDefinitions(String location)方法
AbstractXmlApplicationContext#loadBeanDefinitions(String… locations) >>> AbstractBeanDefinitionReader#loadBeanDefinitions(String location)

public int loadBeanDefinitions(String location) throws BeanDefinitionStoreException {
		return loadBeanDefinitions(location, null);
	}

概述：

AbstractBeanDefinitionReader#loadBeanDefinitions(String location) >>> AbstractBeanDefinitionReader#loadBeanDefinitions(String location, @Nullable Set actualResources)
我们继续进入loadBeanDefinitions(String location, @Nullable Set actualResources)方法，先看一下这个方法的整体代码

public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDefinitionStoreException {
		// 此处获取resourceLoader对象：org.springframework.context.support.ClassPathXmlApplicationContext
		ResourceLoader resourceLoader = getResourceLoader();
		if (resourceLoader == null) {
			throw new BeanDefinitionStoreException(
					"Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");
		}

		if (resourceLoader instanceof ResourcePatternResolver) {
			// Resource pattern matching available.
			try {
				// 调用DefaultResourceLoader的getResource完成具体的Resource定位
				Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
				// 以Resource的方式获取配置文件的资源位置【这里的方法和AbstractXmlApplicationContext#loadBeanDefinitions()里的子方法loadBeanDefinitions(Resource... resources)方法是同一个】
				int loadCount = loadBeanDefinitions(resources);
				if (actualResources != null) {
					for (Resource resource : resources) {
						actualResources.add(resource);
					}
				}
				if (logger.isDebugEnabled()) {
					logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]");
				}
				return loadCount;
			}
			catch (IOException ex) {
				throw new BeanDefinitionStoreException(
						"Could not resolve bean definition resource pattern [" + location + "]", ex);
			}
		}
		else {
			// Can only load single resources by absolute URL.
			Resource resource = resourceLoader.getResource(location);
			int loadCount = loadBeanDefinitions(resource);
			if (actualResources != null) {
				actualResources.add(resource);
			}
			if (logger.isDebugEnabled()) {
				logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");
			}
			return loadCount;
		}
	}

1、ResourceLoader resourceLoader = getResourceLoader();：获取resourceLoader对象
2、getResources(location)：调用DefaultResourceLoader的getResource完成具体的Resource定位
3、loadBeanDefinitions(resources)：根据resource获取文件，并加载到beanDefinition中

详述：
接下来我们对loadBeanDefinitions(String location, @Nullable Set actualResources)方法里重要代码进行详细分析：

3.1、ResourceLoader resourceLoader = getResourceLoader();

在这里插入图片描述
我们debug到第一行代码可以看出此处获取
resourceLoader(org.springframework.context.support.ClassPathXmlApplicationContext)就是我们加载配置文件的类ClassPathXmlApplicationContext。

接着我们可以选中ClassPathXmlApplicationContext类右击show Diagrame方法可以看到该类继承了ResourcePatternResolver类所以该if条件满足，我们继续往下走。
在这里插入图片描述

3.2、Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);

第一步先是调用DefaultResourceLoader的getResource完成具体的Resource定位，我们进入该方法
AbstractBeanDefinitionReader#loadBeanDefinitions(String location, @Nullable Set actualResources) >>> AbstractApplicationContext#getResources(String locationPattern)

	@Override
	public Resource[] getResources(String locationPattern) throws IOException {
		return this.resourcePatternResolver.getResources(locationPattern);
	}

【扩展】
看到这里的resourcePatternResolvers属性，我们要联想到我们在进入容器的刷新refresh()方法之前会先调用父类构造方法，进行相关对象创建等操作，包含属性的赋值操作,而resourcePatternResolvers就是其中的一个对象，我们可以一直F7走下去，可以看到该对象的创建。
在这里插入图片描述

回顾完以前我们学的东西我们再回过来继续分析当前的方法：
PathMatchingResourcePatternResolver#getResources(String locationPattern)

可以看到以上的条件不满足，直接走到最后一步返回，返回一个Resource[]数组。

3.3、int loadCount = loadBeanDefinitions(resources);

**AbstractBeanDefinitionReader#loadBeanDefinitions(String location, @Nullable Set actualResources) >>> AbstractBeanDefinitionReader#loadBeanDefinitions(Resource… resources)
我们F7进入该方法，具体代码如下：

@Override
	public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {
		Assert.notNull(resources, "Resource array must not be null");
		int counter = 0;
		for (Resource resource : resources) {
			counter += loadBeanDefinitions(resource);
		}
		return counter;
	}

AbstractBeanDefinitionReader#loadBeanDefinitions(Resource… resources) >>> XmlBeanDefinitionReader#loadBeanDefinitions(Resource resource)

@Override
	public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
		return loadBeanDefinitions(new EncodedResource(resource));
	}

XmlBeanDefinitionReader#loadBeanDefinitions(Resource resource) >>> XmlBeanDefinitionReader#loadBeanDefinitions(EncodedResource encodedResource)

该方法主要就是对每个resource资源进行单一的加载成BeanDefinition对象

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

		// 通过属性来记录已经加载的资源
		Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
		if (currentResources == null) {
			currentResources = new HashSet<>(4);
			this.resourcesCurrentlyBeingLoaded.set(currentResources);
		}
		if (!currentResources.add(encodedResource)) {
			throw new BeanDefinitionStoreException(
					"Detected cyclic loading of " + encodedResource + " - check your import definitions!");
		}
		// 从encodedResource中获取已经封装的Resource对象并再次从Resource中获取其中的inputStream
		try {
			InputStream inputStream = encodedResource.getResource().getInputStream();
			try {
				InputSource inputSource = new InputSource(inputStream);
				if (encodedResource.getEncoding() != null) {
					inputSource.setEncoding(encodedResource.getEncoding());
				}
				// 逻辑处理的核心步骤
				return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
			}
			finally {
				inputStream.close();
			}
		}
		catch (IOException ex) {
			throw new BeanDefinitionStoreException(
					"IOException parsing XML document from " + encodedResource.getResource(), ex);
		}
		finally {
			currentResources.remove(encodedResource);
			if (currentResources.isEmpty()) {
				this.resourcesCurrentlyBeingLoaded.remove();
			}
		}
	}

3.3.1、逻辑处理的核心步骤 - doLoadBeanDefinitions()

在这里插入图片描述

该方法是我们加载配置文件的核心，先获取XML文件的document对象，这个解析过程是由documentLoader完成的，从String[] - string - Resource[] -resource，最终开始将resource读取成一个document文档，根据文档的节点信息封装成一个个的BeanDefinition对象

XmlBeanDefinitionReader#loadBeanDefinitions(EncodedResource encodedResource) >>> XmlBeanDefinitionReader#doLoadBeanDefinitions(InputSource inputSource, Resource resource)

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
			throws BeanDefinitionStoreException {
		try {
			// 此处获取XML文件的document对象，这个解析过程是由documentLoader完成的，从String[] - string - Resource[] -resource,
			// 最终开始将resource读取成一个document文档，根据文档的节点信息封装成一个个的BeanDefinition对象
			Document doc = doLoadDocument(inputSource, resource);
			return registerBeanDefinitions(doc, resource);
		}
		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);
		}
	}

3.3.1.1、获取XML文件的document对象 - doLoadDocument()

XmlBeanDefinitionReader#doLoadDocument(InputSource inputSource, Resource resource)

protected Document doLoadDocument(InputSource inputSource, Resource resource) throws Exception {
		return this.documentLoader.loadDocument(inputSource, getEntityResolver(), this.errorHandler,
				getValidationModeForResource(resource), isNamespaceAware());
	}

1.1、 XmlBeanDefinitionReader#doLoadDocument(InputSource inputSource, Resource resource) >>> DefaultDocumentLoader#loadDocument()

@Override
	public Document loadDocument(InputSource inputSource, EntityResolver entityResolver,
			ErrorHandler errorHandler, int validationMode, boolean namespaceAware) throws Exception {
		// 创建DocumentBuilderFactory工厂
		DocumentBuilderFactory factory = createDocumentBuilderFactory(validationMode, namespaceAware);
		if (logger.isDebugEnabled()) {
			logger.debug("Using JAXP provider [" + factory.getClass().getName() + "]");
		}
		// 创建DocumentBuilder构建对象
		DocumentBuilder builder = createDocumentBuilder(factory, entityResolver, errorHandler);
		// 进行解析
		return builder.parse(inputSource);
	}

1.2、 XmlBeanDefinitionReader#doLoadDocument(InputSource inputSource, Resource resource) >>> XmlBeanDefinitionReader#getValidationModeForResource(Resource resource)

protected int getValidationModeForResource(Resource resource) {
		int validationModeToUse = getValidationMode();
		// 如果手动指定了验证模式，则使用指定的验证模式
		if (validationModeToUse != VALIDATION_AUTO) {
			return validationModeToUse;
		}
		// 如果没有指定则使用自动检测
		int detectedMode = detectValidationMode(resource);
		if (detectedMode != VALIDATION_AUTO) {
			return detectedMode;
		}
		// Hmm, we didn't get a clear indication... Let's assume XSD,
		// since apparently no DTD declaration has been found up until
		// detection stopped (before finding the document's root tag).
		return VALIDATION_XSD;
	}

1.2.1、getValidationMode();方法获取的值为1，因为我们在初始化beanDefinitionReader对象的时候设置xml文件的验证标志。可以或过头来看本文章的第2个方法：初始化beanDefinitionReader对象
在这里插入图片描述

1.2.2、XmlBeanDefinitionReader#getValidationModeForResource(Resource resource) >>> XmlBeanDefinitionReader#detectValidationMode(Resource resource)

protected int detectValidationMode(Resource resource) {
		if (resource.isOpen()) {
			throw new BeanDefinitionStoreException(
					"Passed-in Resource [" + resource + "] contains an open stream: " +
					"cannot determine validation mode automatically. Either pass in a Resource " +
					"that is able to create fresh streams, or explicitly specify the validationMode " +
					"on your XmlBeanDefinitionReader instance.");
		}

		InputStream inputStream;
		try {
			inputStream = resource.getInputStream();
		}
		catch (IOException ex) {
			throw new BeanDefinitionStoreException(
					"Unable to determine validation mode for [" + resource + "]: cannot open InputStream. " +
					"Did you attempt to load directly from a SAX InputSource without specifying the " +
					"validationMode on your XmlBeanDefinitionReader instance?", ex);
		}

		try {
			return this.validationModeDetector.detectValidationMode(inputStream);
		}
		catch (IOException ex) {
			throw new BeanDefinitionStoreException("Unable to determine validation mode for [" +
					resource + "]: an error occurred whilst reading from the InputStream.", ex);
		}
	}

1.2.3、XmlBeanDefinitionReader#detectValidationMode(Resource resource) >>> XmlValidationModeDetector#detectValidationMode(InputStream inputStream)
在这里插入图片描述

public int detectValidationMode(InputStream inputStream) throws IOException {
		// Peek into the file to look for DOCTYPE.
		BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
		try {
			boolean isDtdValidated = false;
			String content;
			while ((content = reader.readLine()) != null) {
				content = consumeCommentTokens(content);
				// 如果读取的行是空或者注释则略过
				if (this.inComment || !StringUtils.hasText(content)) {
					continue;
				}
				if (hasDoctype(content)) {
					isDtdValidated = true;
					break;
				}
				// 读取都<开始符号
				if (hasOpeningTag(content)) {
					// End of meaningful data...
					break;
				}
			}
			return (isDtdValidated ? VALIDATION_DTD : VALIDATION_XSD);
		}
		catch (CharConversionException ex) {
			// Choked on some character encoding...
			// Leave the decision up to the caller.
			return VALIDATION_AUTO;
		}
		finally {
			reader.close();
		}
	}

3.3.1.2、文档的节点信息封装成BeanDefinition对象：registerBeanDefinitions()

XmlBeanDefinitionReader#registerBeanDefinitions(Document doc, Resource resource)
该方法主要就是对xml的beanDefinition进行解析，完成具体的解析过程

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
		// 对xml的beanDefinition进行解析
		BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
		int countBefore = getRegistry().getBeanDefinitionCount();
		// 完成具体的解析过程
		documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
		return getRegistry().getBeanDefinitionCount() - countBefore;
	}

DefaultBeanDefinitionDocumentReader#registerBeanDefinitions(Document doc, XmlReaderContext readerContext)

@Override
	public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
		this.readerContext = readerContext;
		logger.debug("Loading bean definitions");
		Element root = doc.getDocumentElement();
		// 根据文档的节点信息封装成一个个的BeanDefinition对象，并放到池子中
		doRegisterBeanDefinitions(root);
	}

根据文档的节点信息封装成一个个的BeanDefinition对象，并放到池子中
DefaultBeanDefinitionDocumentReader#doRegisterBeanDefinitions(Element root)

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);
				if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
					if (logger.isInfoEnabled()) {
						logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec +
								"] not matching: " + getReaderContext().getResource());
					}
					return;
				}
			}
		}
		preProcessXml(root);
		// 解析bean定义信息 root：根节点   this.delegate：解析器
		parseBeanDefinitions(root, this.delegate);
		postProcessXml(root);

		this.delegate = parent;
	}

@@@ 解析bean定义信息 - parseBeanDefinitions()

DefaultBeanDefinitionDocumentReader#doRegisterBeanDefinitions(Element root) >>> DefaultBeanDefinitionDocumentReader#parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate)

/**
 * root:根节点
 * delegate:解析器
 */
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);
		}
	}

1)、默认标签解析 - parseDefaultElement()

DefaultBeanDefinitionDocumentReader#parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate)

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
		// import标签
		if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
			importBeanDefinitionResource(ele);
		}
		// alias标签
		else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
			processAliasRegistration(ele);
		}
		// bean标签
		else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
			processBeanDefinition(ele, delegate);
		}
		// nested_beans标签
		else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
			// recurse
			doRegisterBeanDefinitions(ele);
		}
	}

@@@ bean标签解析 - processBeanDefinition()

概述：

按照Spring的bean规则进行解析xml元素的信息得到BeanDefinition，并向向ioc注册解析得到的beanDefinition的地方，最后，在beandefinition向ioc容器注册完之后，发送消息。
DefaultBeanDefinitionDocumentReader#processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate)

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
		// beanDefinitionholder是beanDefinition对象的封装类，封装了BeanDefinition,bean的名字和别名，用它来完成向IOC容器的注册
		// 得到这个beanDefinitionHolder就意味着beandefinition是通过BeanDefinitionParserDelegate对xml元素的信息按照spring的bean规则进行解析得到的
		BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
		if (bdHolder != null) {
			// 是否有适用于修饰的BeanDefinition
			bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
			try {
				// Register the final decorated instance.
				// 向ioc注册解析得到的beanDefinition的地方
				BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
			}
			catch (BeanDefinitionStoreException ex) {
				getReaderContext().error("Failed to register bean definition with name '" +
						bdHolder.getBeanName() + "'", ele, ex);
			}
			// Send registration event.
			// 在beandefinition向ioc容器注册完之后，发送消息
			getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
		}
	}

下面简单概括一下上面的bean标签解析步骤

delegate.parseBeanDefinitionElement(ele)：beanDefinitionholder是beanDefinition对象的封装类，封装了BeanDefinition,bean的名字和别名，用它来完成向IOC容器的注册。
decorateBeanDefinitionIfRequired(ele, bdHolder)：是否有适用于修饰的BeanDefinition
registerBeanDefinition(bdHolder, getReaderContext().getRegistry())：向ioc注册解析得到的beanDefinition的地方
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder))：在beandefinition向ioc容器注册完之后，发送消息

详述：

1、parseBeanDefinitionElement()

beanDefinitionholder是beanDefinition对象的封装类，封装了BeanDefinition,bean的名字和别名，用它来完成向IOC容器的注册; 得到这个beanDefinitionHolder就意味着beandefinition是通过BeanDefinitionParserDelegate对xml元素的信息按照spring的bean规则进行解析得到的
BeanDefinitionParserDelegate#parseBeanDefinitionElement(Element ele)

@Nullable
	public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
		return parseBeanDefinitionElement(ele, null);
	}

BeanDefinitionParserDelegate#parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean)

@Nullable
	public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
		// 解析id属性
 		String id = ele.getAttribute(ID_ATTRIBUTE);
 		// 解析name属性
		String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
		// 如果bean有别名的话，那么将别名进行分割解析
		List<String> aliases = new ArrayList<>();
		if (StringUtils.hasLength(nameAttr)) {
			String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
			aliases.addAll(Arrays.asList(nameArr));
		}

		String beanName = id;
		if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
			beanName = aliases.remove(0);
			if (logger.isDebugEnabled()) {
				logger.debug("No XML 'id' specified - using '" + beanName +
						"' as bean name and " + aliases + " as aliases");
			}
		}
		// 校验beanName是否是唯一的
		if (containingBean == null) {
			checkNameUniqueness(beanName, aliases, ele);
		}

		// 对bean元素的详细解析
		AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
		if (beanDefinition != null) {
			if (!StringUtils.hasText(beanName)) {
				try {
					// 如果不存在beanName,那么根据spring中提供的命名规则为当前bean生成对应的beanName
					if (containingBean != null) {
						beanName = BeanDefinitionReaderUtils.generateBeanName(
								beanDefinition, this.readerContext.getRegistry(), true);
					}
					else {
						beanName = this.readerContext.generateBeanName(beanDefinition);
						String beanClassName = beanDefinition.getBeanClassName();
						if (beanClassName != null &&
								beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
								!this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
							aliases.add(beanClassName);
						}
					}
					if (logger.isDebugEnabled()) {
						logger.debug("Neither XML 'id' nor 'name' specified - " +
								"using generated bean name [" + beanName + "]");
					}
				}
				catch (Exception ex) {
					error(ex.getMessage(), ele);
					return null;
				}
			}
			String[] aliasesArray = StringUtils.toStringArray(aliases);
			return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
		}

		return null;
	}

1.1、对bean元素的详细解析 - parseBeanDefinitionElement()

BeanDefinitionParserDelegate#parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) >>> parseBeanDefinitionElement()

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

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

 		// 解析class属性
		String className = null;
		if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
			className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
		}
		// 解析parent属性
		String parent = null;
		if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
			parent = ele.getAttribute(PARENT_ATTRIBUTE);
		}

		try {
			// 创建装在bean信息的AbstractBeanDefinition对象，实际的实现是GenericBeanDefinition
			AbstractBeanDefinition bd = createBeanDefinition(className, parent);

			// 解析bean标签的各种其他属性
			parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
			// 设置description信息
			bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));

			// 解析元数据
			parseMetaElements(ele, bd);
			// 解析lookup-method属性
			parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
			// 解析replaced-method属性
			parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

			// 解析构造函数参数
			parseConstructorArgElements(ele, bd);
			// 解析property子元素
			parsePropertyElements(ele, bd);
			// 解析qualifier子元素
			parseQualifierElements(ele, bd);

			bd.setResource(this.readerContext.getResource());
			bd.setSource(extractSource(ele));

			return bd;
		}
		catch (ClassNotFoundException ex) {
			error("Bean class [" + className + "] not found", ele, ex);
		}
		catch (NoClassDefFoundError err) {
			error("Class that bean class [" + className + "] depends on not found", ele, err);
		}
		catch (Throwable ex) {
			error("Unexpected failure during bean definition parsing", ele, ex);
		}
		finally {
			this.parseState.pop();
		}

		return null;
	}

解析元数据 - parseMetaElements(ele, bd);

public void parseMetaElements(Element ele, BeanMetadataAttributeAccessor attributeAccessor) {
		// 获取当前节点的所有子元素
		NodeList nl = ele.getChildNodes();
		for (int i = 0; i < nl.getLength(); i++) {
			Node node = nl.item(i);
			// 提取meta
			if (isCandidateElement(node) && nodeNameEquals(node, META_ELEMENT)) {
				Element metaElement = (Element) node;
				String key = metaElement.getAttribute(KEY_ATTRIBUTE);
				String value = metaElement.getAttribute(VALUE_ATTRIBUTE);
				// 使用key、value构造beanMetadataAttribute
				BeanMetadataAttribute attribute = new BeanMetadataAttribute(key, value);
				attribute.setSource(extractSource(metaElement));
				// 记录信息
				attributeAccessor.addMetadataAttribute(attribute);
			}
		}
	}

解析lookup-method属性 - parseLookupOverrideSubElements(ele, bd.getMethodOverrides());

public void parseLookupOverrideSubElements(Element beanEle, MethodOverrides overrides) {
		NodeList nl = beanEle.getChildNodes();
		for (int i = 0; i < nl.getLength(); i++) {
			Node node = nl.item(i);
			// 仅当spring默认bean的子元素下且为<lookup-method>时有效
			if (isCandidateElement(node) && nodeNameEquals(node, LOOKUP_METHOD_ELEMENT)) {
				Element ele = (Element) node;
				// 获取要修饰的方法
				String methodName = ele.getAttribute(NAME_ATTRIBUTE);
				// 获取配置返回的bean
				String beanRef = ele.getAttribute(BEAN_ELEMENT);
				LookupOverride override = new LookupOverride(methodName, beanRef);
				override.setSource(extractSource(ele));
				overrides.addOverride(override);
			}
		}
	}

解析构造函数参数 - parseConstructorArgElements(ele, bd);

public void parseConstructorArgElements(Element beanEle, BeanDefinition bd) {
		NodeList nl = beanEle.getChildNodes();
		for (int i = 0; i < nl.getLength(); i++) {
			Node node = nl.item(i);
			if (isCandidateElement(node) && nodeNameEquals(node, CONSTRUCTOR_ARG_ELEMENT)) {
				parseConstructorArgElement((Element) node, bd);
			}
		}
	}

BeanDefinitionParserDelegate#parseConstructorArgElement(Element ele, BeanDefinition bd)

public void parseConstructorArgElement(Element ele, BeanDefinition bd) {
		// 获取index属性
		String indexAttr = ele.getAttribute(INDEX_ATTRIBUTE);
		// 获取type属性
		String typeAttr = ele.getAttribute(TYPE_ATTRIBUTE);
		// 获取name属性
		String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
		if (StringUtils.hasLength(indexAttr)) {
			try {
				int index = Integer.parseInt(indexAttr);
				if (index < 0) {
					error("'index' cannot be lower than 0", ele);
				}
				else {
					try {
						this.parseState.push(new ConstructorArgumentEntry(index));
						// 解析ele对应的属性元素
						Object value = parsePropertyValue(ele, bd, null);
						ConstructorArgumentValues.ValueHolder valueHolder = new ConstructorArgumentValues.ValueHolder(value);
						if (StringUtils.hasLength(typeAttr)) {
							valueHolder.setType(typeAttr);
						}
						if (StringUtils.hasLength(nameAttr)) {
							valueHolder.setName(nameAttr);
						}
						valueHolder.setSource(extractSource(ele));
						// 不允许重复指定相同参数
						if (bd.getConstructorArgumentValues().hasIndexedArgumentValue(index)) {
							error("Ambiguous constructor-arg entries for index " + index, ele);
						}
						else {
							bd.getConstructorArgumentValues().addIndexedArgumentValue(index, valueHolder);
						}
					}
					finally {
						this.parseState.pop();
					}
				}
			}
			catch (NumberFormatException ex) {
				error("Attribute 'index' of tag 'constructor-arg' must be an integer", ele);
			}
		}
		else {
			try {
				this.parseState.push(new ConstructorArgumentEntry());
				Object value = parsePropertyValue(ele, bd, null);
				ConstructorArgumentValues.ValueHolder valueHolder = new ConstructorArgumentValues.ValueHolder(value);
				if (StringUtils.hasLength(typeAttr)) {
					valueHolder.setType(typeAttr);
				}
				if (StringUtils.hasLength(nameAttr)) {
					valueHolder.setName(nameAttr);
				}
				valueHolder.setSource(extractSource(ele));
				bd.getConstructorArgumentValues().addGenericArgumentValue(valueHolder);
			}
			finally {
				this.parseState.pop();
			}
		}
	}

1)、解析ele对应的属性元素

@Nullable
	public Object parsePropertyValue(Element ele, BeanDefinition bd, @Nullable String propertyName) {
		String elementName = (propertyName != null ?
				"<property> element for property '" + propertyName + "'" :
				"<constructor-arg> element");

		// Should only have one child element: ref, value, list, etc.
		// 一个属性只能对应一种类型，ref、value、list
		NodeList nl = ele.getChildNodes();
		Element subElement = null;
		for (int i = 0; i < nl.getLength(); i++) {
			Node node = nl.item(i);
			// 如果匹配到description或者meta不处理
			if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT) &&
					!nodeNameEquals(node, META_ELEMENT)) {
				// Child element is what we're looking for.
				if (subElement != null) {
					error(elementName + " must not contain more than one sub-element", ele);
				}
				else {
					subElement = (Element) node;
				}
			}
		}

		// 解析constructor-arg上的ref
		boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE);
		// 解析constructor-arg上的value属性
		boolean hasValueAttribute = ele.hasAttribute(VALUE_ATTRIBUTE);
		if ((hasRefAttribute && hasValueAttribute) ||
				((hasRefAttribute || hasValueAttribute) && subElement != null)) {
			error(elementName +
					" is only allowed to contain either 'ref' attribute OR 'value' attribute OR sub-element", ele);
		}

		if (hasRefAttribute) {
			// ref属性的处理，使用runtimeBeanReference封装对应的ref名称
			String refName = ele.getAttribute(REF_ATTRIBUTE);
			if (!StringUtils.hasText(refName)) {
				error(elementName + " contains empty 'ref' attribute", ele);
			}
			RuntimeBeanReference ref = new RuntimeBeanReference(refName);
			ref.setSource(extractSource(ele));
			return ref;
		}
		else if (hasValueAttribute) {
			// value属性的处理，使用TypeStringValue封装
			TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE));
			valueHolder.setSource(extractSource(ele));
			return valueHolder;
		}
		else if (subElement != null) {
			// 解析子元素
			return parsePropertySubElement(subElement, bd);
		}
		else {
			// Neither child element nor "ref" or "value" attribute found.
			// 如果既没有ref元素也没有value属性，也没有子元素，那么spring会报错
			error(elementName + " must specify a ref or value", ele);
			return null;
		}
	}

1.1)、解析子元素：BeanDefinitionParserDelegate#parsePropertySubElement(Element ele, @Nullable BeanDefinition bd)

@Nullable
	public Object parsePropertySubElement(Element ele, @Nullable BeanDefinition bd) {
		return parsePropertySubElement(ele, bd, null);
	}

BeanDefinitionParserDelegate#parsePropertySubElement(Element ele, @Nullable BeanDefinition bd, @Nullable String defaultValueType)

@Nullable
	public Object parsePropertySubElement(Element ele, @Nullable BeanDefinition bd, @Nullable String defaultValueType) {
		if (!isDefaultNamespace(ele)) {
			return parseNestedCustomElement(ele, bd);
		}
		else if (nodeNameEquals(ele, BEAN_ELEMENT)) {
			BeanDefinitionHolder nestedBd = parseBeanDefinitionElement(ele, bd);
			if (nestedBd != null) {
				nestedBd = decorateBeanDefinitionIfRequired(ele, nestedBd, bd);
			}
			return nestedBd;
		}
		else if (nodeNameEquals(ele, REF_ELEMENT)) {
			// A generic reference to any name of any bean.
			String refName = ele.getAttribute(BEAN_REF_ATTRIBUTE);
			boolean toParent = false;
			if (!StringUtils.hasLength(refName)) {
				// A reference to the id of another bean in a parent context.
				// 解析parent
				refName = ele.getAttribute(PARENT_REF_ATTRIBUTE);
				toParent = true;
				if (!StringUtils.hasLength(refName)) {
					error("'bean' or 'parent' is required for <ref> element", ele);
					return null;
				}
			}
			if (!StringUtils.hasText(refName)) {
				error("<ref> element contains empty target attribute", ele);
				return null;
			}
			RuntimeBeanReference ref = new RuntimeBeanReference(refName, toParent);
			ref.setSource(extractSource(ele));
			return ref;
		}
		// 对idref元素的解析
		else if (nodeNameEquals(ele, IDREF_ELEMENT)) {
			return parseIdRefElement(ele);
		}
		// 对value子元素的解析
		else if (nodeNameEquals(ele, VALUE_ELEMENT)) {
			return parseValueElement(ele, defaultValueType);
		}
		// 对null子元素的解析
		else if (nodeNameEquals(ele, NULL_ELEMENT)) {
			// It's a distinguished null value. Let's wrap it in a TypedStringValue
			// object in order to preserve the source location.
			TypedStringValue nullHolder = new TypedStringValue(null);
			nullHolder.setSource(extractSource(ele));
			return nullHolder;
		}
		else if (nodeNameEquals(ele, ARRAY_ELEMENT)) {
			// 解析array子元素
			return parseArrayElement(ele, bd);
		}
		else if (nodeNameEquals(ele, LIST_ELEMENT)) {
			// 解析list子元素
			return parseListElement(ele, bd);
		}
		else if (nodeNameEquals(ele, SET_ELEMENT)) {
			// 解析set子元素
			return parseSetElement(ele, bd);
		}
		else if (nodeNameEquals(ele, MAP_ELEMENT)) {
			// 解析map子元素
			return parseMapElement(ele, bd);
		}
		else if (nodeNameEquals(ele, PROPS_ELEMENT)) {
			// 解析props子元素
			return parsePropsElement(ele);
		}
		else {
			error("Unknown property sub-element: [" + ele.getNodeName() + "]", ele);
			return null;
		}
	}

解析property子元素：parsePropertyElements(ele, bd);

public void parsePropertyElements(Element beanEle, BeanDefinition bd) {
		NodeList nl = beanEle.getChildNodes();
		for (int i = 0; i < nl.getLength(); i++) {
			Node node = nl.item(i);
			// 判断是否是property元素，然后对其进行解析操作
			if (isCandidateElement(node) && nodeNameEquals(node, PROPERTY_ELEMENT)) {
				parsePropertyElement((Element) node, bd);
			}
		}
	}

BeanDefinitionParserDelegate#parsePropertyElement(Element ele, BeanDefinition bd)

public void parsePropertyElement(Element ele, BeanDefinition bd) {
		// 获取配置元素name值
		String propertyName = ele.getAttribute(NAME_ATTRIBUTE);
		if (!StringUtils.hasLength(propertyName)) {
			error("Tag 'property' must have a 'name' attribute", ele);
			return;
		}
		this.parseState.push(new PropertyEntry(propertyName));
		try {
			// 不允许多次对同一属性配置，如果已经存在同名的property属性，那么就不进行解析
			if (bd.getPropertyValues().contains(propertyName)) {
				error("Multiple 'property' definitions for property '" + propertyName + "'", ele);
				return;
			}
			// 此处用来解析property值，返回的对象对应对bean定义的property属性设置的解析结果，这个解析结果会封装到PropertyValue对象中，
			// 然后设置BeanDefinitionHolder去
			Object val = parsePropertyValue(ele, bd, propertyName);
			PropertyValue pv = new PropertyValue(propertyName, val);
			parseMetaElements(ele, pv);
			pv.setSource(extractSource(ele));
			bd.getPropertyValues().addPropertyValue(pv);
		}
		finally {
			this.parseState.pop();
		}
	}

2、对bean元素的详细解析 - decorateBeanDefinitionIfRequired()

2.1、BeanDefinitionParserDelegate#decorateBeanDefinitionIfRequired()

public BeanDefinitionHolder decorateBeanDefinitionIfRequired(Element ele, BeanDefinitionHolder originalDef) {
		return decorateBeanDefinitionIfRequired(ele, originalDef, null);
	}

2.2、BeanDefinitionParserDelegate#decorateBeanDefinitionIfRequired(Element ele, BeanDefinitionHolder originalDef, @Nullable BeanDefinition containingBd)

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

2.3、BeanDefinitionParserDelegate#decorateIfRequired(Node node, BeanDefinitionHolder originalDef, @Nullable BeanDefinition containingBd)

public BeanDefinitionHolder decorateIfRequired(
			Node node, BeanDefinitionHolder originalDef, @Nullable BeanDefinition containingBd) {

		// 获取自定义标签的命名空间
		String namespaceUri = getNamespaceURI(node);
		// 对非默认标签进行修饰
		if (namespaceUri != null && !isDefaultNamespace(namespaceUri)) {
			// 根据命名空间找到对应的处理器
			NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
			if (handler != null) {
				// 进行装饰
				BeanDefinitionHolder decorated =
						handler.decorate(node, originalDef, new ParserContext(this.readerContext, this, containingBd));
				if (decorated != null) {
					return decorated;
				}
			}
			else if (namespaceUri.startsWith("http://www.springframework.org/")) {
				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;
	}

3、向ioc注册解析得到的beanDefinition的地方 - registerBeanDefinition(）

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

3.1、DefaultListableBeanFactory#registerBeanDefinition(String beanName, BeanDefinition beanDefinition)**

public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
			throws BeanDefinitionStoreException {

		Assert.hasText(beanName, "Bean name must not be empty");
		Assert.notNull(beanDefinition, "BeanDefinition must not be null");

		if (beanDefinition instanceof AbstractBeanDefinition) {
			try {
				// 注册前的最后一个校验，这里的校验不同于之前的xml校验，只要对应abstractBeanDefinition属性的methodOverrides校验
				((AbstractBeanDefinition) beanDefinition).validate();
			}
			catch (BeanDefinitionValidationException ex) {
				throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
						"Validation of bean definition failed", ex);
			}
		}

		BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
		// 处理注册已经注册beanName的情况
		if (existingDefinition != null) {
			// 如果对应的beanName已经注册且在配置中配置了bean不允许被覆盖，则抛除异常
			if (!isAllowBeanDefinitionOverriding()) {
				throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
						"Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
						"': There is already [" + existingDefinition + "] bound.");
			}
			else if (existingDefinition.getRole() < beanDefinition.getRole()) {
				// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
				if (logger.isWarnEnabled()) {
					logger.warn("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.isInfoEnabled()) {
					logger.info("Overriding bean definition for bean '" + beanName +
							"' with a different definition: replacing [" + existingDefinition +
							"] with [" + beanDefinition + "]");
				}
			}
			else {
				if (logger.isDebugEnabled()) {
					logger.debug("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;
					if (this.manualSingletonNames.contains(beanName)) {
						Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
						updatedSingletons.remove(beanName);
						this.manualSingletonNames = updatedSingletons;
					}
				}
			}
			else {
				// Still in startup registration phase
				// 注册beanDefinition
				this.beanDefinitionMap.put(beanName, beanDefinition);
				// 记录beanName
				this.beanDefinitionNames.add(beanName);
				this.manualSingletonNames.remove(beanName);
			}
			this.frozenBeanDefinitionNames = null;
		}

		if (existingDefinition != null || containsSingleton(beanName)) {
			// 重置所有beanName对应的缓存
			resetBeanDefinition(beanName);
		}
		else if (isConfigurationFrozen()) {
			clearByTypeCache();
		}
	}

3.2、注册所有别名 - registerAlias()

AliasRegistry#registerAlias(String name, String alias)

void registerAlias(String name, String alias);

@Override
public void registerAlias(String beanName, String alias) {
		this.beanFactory.registerAlias(beanName, alias);
	}

@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) {
			// 如果beanName与alias相同的话不记录alias,并删除alias
			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;
					}
					// 如果alias不允许被覆盖则抛除异常
					if (!allowAliasOverriding()) {
						throw new IllegalStateException("Cannot define alias '" + alias + "' for name '" +
								name + "': It is already registered for name '" + registeredName + "'.");
					}
					if (logger.isInfoEnabled()) {
						logger.info("Overriding alias '" + alias + "' definition for registered name '" +
								registeredName + "' with new target name '" + name + "'");
					}
				}
				// 当A->B存在时，若再次出现A->C->B的时候会抛除异常
				checkForAliasCircle(name, alias);
				this.aliasMap.put(alias, name);
				if (logger.isDebugEnabled()) {
					logger.debug("Alias definition '" + alias + "' registered for name '" + name + "'");
				}
			}
		}
	}

4、在beandefinition向ioc容器注册完之后，发送消息

ReaderContext#fireComponentRegistered()

public void fireComponentRegistered(ComponentDefinition componentDefinition) {
		this.eventListener.componentRegistered(componentDefinition);
	}

ReaderEventListener#componentRegistered()

void componentRegistered(ComponentDefinition componentDefinition);

CollectingReaderEventListener#componentRegistered()

@Override
	public void componentRegistered(ComponentDefinition componentDefinition) {
		this.componentDefinitions.put(componentDefinition.getName(), componentDefinition);
	}

2）、自定义标签解析

BeanDefinitionParserDelegate#parseCustomElement(Element ele)

@Nullable
	public BeanDefinition parseCustomElement(Element ele) {
		return parseCustomElement(ele, null);
	}

BeanDefinitionParserDelegate#parseCustomElement(Element ele, @Nullable BeanDefinition containingBd)

@Nullable
	public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
		// 获取对应的命名空间
		String namespaceUri = getNamespaceURI(ele);
		if (namespaceUri == null) {
			return null;
		}
		// 根据命名空间找到对应的NamespaceHandler
		NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
		if (handler == null) {
			error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
			return null;
		}
		// 调用自定义的NamespaceHandler进行解析
		return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
	}

【扩展】
在这里插入图片描述
XmlBeanDefinitionReader#registerBeanDefinitions(Document doc, Resource resource)
在完成具体的解析过程的方法里已经创建了

XmlBeanDefinitionReader#createReaderContext(Resource resource)

public XmlReaderContext createReaderContext(Resource resource) {
		return new XmlReaderContext(resource, this.problemReporter, this.eventListener,
				this.sourceExtractor, this, getNamespaceHandlerResolver());
	}

XmlBeanDefinitionReader#getNamespaceHandlerResolver()

public NamespaceHandlerResolver getNamespaceHandlerResolver() {
		if (this.namespaceHandlerResolver == null) {
			this.namespaceHandlerResolver = createDefaultNamespaceHandlerResolver();
		}
		return this.namespaceHandlerResolver;
	}

XmlBeanDefinitionReader#createDefaultNamespaceHandlerResolver()

protected NamespaceHandlerResolver createDefaultNamespaceHandlerResolver() {
		ClassLoader cl = (getResourceLoader() != null ? getResourceLoader().getClassLoader() : getBeanClassLoader());
		return new DefaultNamespaceHandlerResolver(cl);
	}

DefaultNamespaceHandlerResolver#DefaultNamespaceHandlerResolver(@Nullable ClassLoader classLoader)
在这里插入图片描述

public DefaultNamespaceHandlerResolver(@Nullable ClassLoader classLoader) {
		this(classLoader, DEFAULT_HANDLER_MAPPINGS_LOCATION);
	}

1、根据命名空间找到对应的NamespaceHandler - resolve()

BeanDefinitionParserDelegate#parseCustomElement() >>> DefaultNamespaceHandlerResolver# resolve(String namespaceUri)

@Override
	@Nullable
	public NamespaceHandler resolve(String namespaceUri) {
		// 获取所有已经配置好的handler映射
		Map<String, Object> handlerMappings = getHandlerMappings();
		// 根据命名空间找到对应的信息
		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);
				// 调用自定义的namespaceHandler的初始化方法
				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);
			}
		}
	}

2、调用自定义的NamespaceHandler进行解析 - parse()

NamespaceHandlerSupport#parse(Element element, ParserContext parserContext)

@Override
	@Nullable
	public BeanDefinition parse(Element element, ParserContext parserContext) {
		// 获取元素的解析器
		BeanDefinitionParser parser = findParserForElement(element, parserContext);
		return (parser != null ? parser.parse(element, parserContext) : null);
	}

NamespaceHandlerSupport#findParserForElement(Element element, ParserContext parserContext)

@Nullable
	private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {
		// 获取元素名称
		String localName = parserContext.getDelegate().getLocalName(element);
		// 根据元素名称找到对应的解析器
		BeanDefinitionParser parser = this.parsers.get(localName);
		if (parser == null) {
			parserContext.getReaderContext().fatal(
					"Cannot locate BeanDefinitionParser for element [" + localName + "]", element);
		}
		return parser;
	}

此时返回的元素的解析器，我们拿到元素的解析器再对自定义标签进行解析

	@Override
	@Nullable
	public final BeanDefinition parse(Element element, ParserContext parserContext) {
		// 自定义标签解析成BeanDefinition对象
		AbstractBeanDefinition definition = parseInternal(element, parserContext);
		if (definition != null && !parserContext.isNested()) {
			try {
				String id = resolveId(element, definition, parserContext);
				if (!StringUtils.hasText(id)) {
					parserContext.getReaderContext().error(
							"Id is required for element '" + parserContext.getDelegate().getLocalName(element)
									+ "' when used as a top-level tag", element);
				}
				String[] aliases = null;
				if (shouldParseNameAsAliases()) {
					String name = element.getAttribute(NAME_ATTRIBUTE);
					if (StringUtils.hasLength(name)) {
						aliases = StringUtils.trimArrayElements(StringUtils.commaDelimitedListToStringArray(name));
					}
				}
				// 将AbstractBeanDefinition转化为BeanDefinitionHolder处理
				BeanDefinitionHolder holder = new BeanDefinitionHolder(definition, id, aliases);
				registerBeanDefinition(holder, parserContext.getRegistry());
				if (shouldFireEvents()) {
					// 通知监听器进行处理
					BeanComponentDefinition componentDefinition = new BeanComponentDefinition(holder);
					postProcessComponentDefinition(componentDefinition);
					parserContext.registerComponent(componentDefinition);
				}
			}
			catch (BeanDefinitionStoreException ex) {
				String msg = ex.getMessage();
				parserContext.getReaderContext().error((msg != null ? msg : ex.toString()), element);
				return null;
			}
		}
		return definition;
	}

2.1、自定义标签解析成BeanDefinition对象 - parseInternal()

AbstractSingleBeanDefinitionParser#parseInternal()

protected final AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
		BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();
		String parentName = getParentName(element);
		if (parentName != null) {
			builder.getRawBeanDefinition().setParentName(parentName);
		}
		// 获取自定义标签中的class,此时会调用自定义解析器
		Class<?> beanClass = getBeanClass(element);
		if (beanClass != null) {
			builder.getRawBeanDefinition().setBeanClass(beanClass);
		}
		else {
			// 若子类没有重写getBeanClass方法则尝试检查子类是否重写getBeanClassName方法
			String beanClassName = getBeanClassName(element);
			if (beanClassName != null) {
				builder.getRawBeanDefinition().setBeanClassName(beanClassName);
			}
		}
		builder.getRawBeanDefinition().setSource(parserContext.extractSource(element));
		BeanDefinition containingBd = parserContext.getContainingBeanDefinition();
		if (containingBd != null) {
			// Inner bean definition must receive same scope as containing bean.
			// 若存在父类则使用父类的scope属性
			builder.setScope(containingBd.getScope());
		}
		if (parserContext.isDefaultLazyInit()) {
			// Default-lazy-init applies to custom bean definitions as well.
			// 配置延迟加载
			builder.setLazyInit(true);
		}
		// 调用子类重写的doParse方法进行解析
		doParse(element, parserContext, builder);
		return builder.getBeanDefinition();
	}

2.2、registerBeanDefinition()

将配置文件的属性解析成beanDefinition对象，并注册到beanDefinitionMap池子中以及记录beanDefinitionNames中，下面的代码我们再默认标签解析中也出现过，就不详细分析
AbstractBeanDefinitionParser#registerBeanDefinition()

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

BeanDefinitionReaderUtils#registerBeanDefinition()

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

四、手写模拟自定义标签

在这里插入图片描述

写一个User类：com.wts.selfTag.User

public class User {

	private String username;

	private String password;

	private String email;

	public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

	public String getEmail() {
		return email;
	}

	public void setEmail(String email) {
		this.email = email;
	}

}

创建一个类com.wts.selfTag.UserBeanDefinitionParser对当前User类的标签进行一个解析工作

public class UserBeanDefinitionParser extends AbstractSingleBeanDefinitionParser {

	/**
	 * 返回属性值所对应的对象
	 * @param element the {@code Element} that is being parsed
	 * @return
	 */
	@Override
	protected Class<?> getBeanClass(Element element) {
		return User.class;
	}

	@Override
	protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
		// 获取标签具备的属性值
		String username = element.getAttribute("username");
		String password = element.getAttribute("password");
		String email = element.getAttribute("email");

		if (StringUtils.hasText(username)) {
			builder.addPropertyValue("username", username);
		}

		if (StringUtils.hasText(password)) {
			builder.addPropertyValue("password", password);
		}

		if (StringUtils.hasText(email)) {
			builder.addPropertyValue("email", email);
		}

	}
}

public class UserNameSpaceHandler extends NamespaceHandlerSupport {
	@Override
	public void init() {
		registerBeanDefinitionParser("user", new UserBeanDefinitionParser());
	}
}

创建对应的解析器处理类(在init方法中添加parser类)

public class UserNameSpaceHandler extends NamespaceHandlerSupport {
	@Override
	public void init() {
		registerBeanDefinitionParser("user", new UserBeanDefinitionParser());
	}
}

创建META-INF/spring.handlers

http\://www.wts.com/schema/user=com.wts.selfTag.UserNameSpaceHandler

创建META-INF/spring.schemas

http\://www.wts.com/schema/user.xsd=META-INF/user.xsd

创建META-INF/user.xsd

<?xml version="1.0" encoding="UTF-8" standalone="no"?>

<schema xmlns="http://www.w3.org/2001/XMLSchema"
		targetNamespace="http://www.wts.com/schema/user"
		xmlns:tns="http://www.wts.com/schema/user"
		elementFormDefault="qualified">

	<element name="user" >
		<complexType>
			<attribute name="id" type="string"></attribute>
			<attribute name="username" type="string"></attribute>
			<attribute name="password" type="string"></attribute>
			<attribute name="email" type="string"></attribute>
		</complexType>
	</element>

</schema>

修改application.xml配置添加自定义的标签wts:user

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:context="http://www.springframework.org/schema/context"
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	   xmlns:wts="http://www.wts.com/schema/user"
	   xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
		http://www.wts.com/schema/user http://www.wts.com/schema/user.xsd">
	<!--把对象的创建交给spring来管理-->
	<!--自定义命名空间-->
	<wts:user id="wts" username="lisi" email="com" password="123456"></wts:user>
	<context:property-placeholder location="classpath:db.properties"></context:property-placeholder>
	<!--bean命名空间-->
	<bean id="person2" class="com.wts.Person">
		<property name="id" value="1"></property>
		<property name="name" value="lisi"></property>
	</bean>
</beans>

修改测试类：com.wts.Test

public class Test {
	public static void main(String[] args) {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
		User user = (User) applicationContext.getBean("wts");
		System.out.println(user.getUsername());
	}
}

测试结果：
在这里插入图片描述
以上：内容部分参考
《Spring源码深度解析》
如有侵扰，联系删除。内容仅用于自我记录学习使用。如有错误，欢迎指正

代码的知行者

关注

2
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
Spring源码深度解析：四、Spring配置文件加载流程

接下来我们学习Spring配置文件加载流程，主要加载xml配置文件的属性值到当前工厂中，最重要的就是BeanDefinitionAbstractApplicationContext#obtainFreshBeanFactory()首先我们debug进入spring的刷新方法，接着进入子方法该方法先创建容器对象：，然后加载xml配置文件的属性值到当前工厂中，最重要的就是BeanDefinition。具体代码如下：AbstractApplicationContext#refreshBeanFactory()
复制链接

扫一扫