Spring源码之XML默认标签解析

た入场券 2023-10-02 12:54 44阅读 0赞

Spring源码分析：

1.  [Spring源码：源码编译及阅读源码入门][Spring]
2.  [Spring源码：XML默认标签解析][Spring_XML]
3.  [Spring源码：自定义标签解析][Spring 1]
4.  [Spring源码：Bean工厂的后置处理器invokeBeanFactoryPostProcessors][Spring_Bean_invokeBeanFactoryPostProcessors]

Spring具有非常庞大的体系，但无论多大都是由一个个小的模块组合而来，不管是 SpringMVC 还是 SpringBoot，都是在Spring的基础上延伸而来，因此，看源码要找对方向。

我们知道，在SpringBoot之前，对象的管理和配置都是通过XML的方式来实现的，那么Spring是怎么读取配置文件，并且管理我们的实体对象的呢？这就需要从Spring容器开始了解。

### 1. 什么是Spring容器 ###

Spring 容器是 Spring 框架的核心，是用来管理对象的。容器将创建对象，把它们连接在一起，配置它们，并管理他们的整个生命周期从创建到销毁。

### 2. Spring容器加载方式 ###

Spring 容器的加载主要有 2 种（不包括SpringBoot），一种是xml的方式`ClassPathXmlApplicationContext`，一种是基于注解的方式`AnnotationConfigApplicationContext`，实际上他们的顶级接口都是`ApplicationContext`。

下面的用例主要就是基于XML的方式来启动Spring容器并查看Bean的创建和管理。

### 3. 创建项目 ###

创建一个基本的 Maven 项目，结构如下：

![image-20211021201814462][]

#### 3.1 pom.xml ####

我们导入`spring-context`即可，它依赖了其他组件，如下：

![image-20211021202633957][]

xml配置如下：

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>cn.javatv</groupId>
        <artifactId>spring-xml</artifactId>
        <version>1.0-SNAPSHOT</version>
    
        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <maven.compiler.source>1.8</maven.compiler.source>
            <maven.compiler.target>1.8</maven.compiler.target>
            <spring.version>5.2.8.RELEASE</spring.version>
        </properties>
    
        <dependencies>
            
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.13</version>
            </dependency>
            
            
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>${spring.version}</version>
            </dependency>
            
            
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>1.16.20</version>
            </dependency>
    
            
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-api</artifactId>
                <version>1.7.10</version>
            </dependency>
            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-classic</artifactId>
                <version>1.1.2</version>
            </dependency>
            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-core</artifactId>
                <version>1.1.2</version>
            </dependency>
        </dependencies>
    </project>

#### 3.2 spring.xml ####

#### 3.3 实例Bean ####

import lombok.Data;
    
    @Data
    public class SpringXml {
        
    
        private String info = "Hello Sprin Xml";
    }

#### 3.4 测试类 ####

import cn.javatv.bean.SpringXml;
    import org.junit.Test;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class MyTest {
        
    
        @Test
        public void test1() {
        
            ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
            SpringXml bean = applicationContext.getBean(SpringXml.class);
            System.out.println(bean.getInfo());
        }
    }

测试输出：

![image-20211021210402630][]

### 4. 谈谈BeanDefinition ###

一般情况下，在一个 Spring 项目中，获取对象的方式有两种，一种是手动直接 new，另一种是交给 Spring 管理，Spring 将管理的对象称之为 Bean，容器会先实例化 Bean，然后自动注入，实例化的过程就需要依赖 BeanDefinition。

BeanDefinition 用于保存 Bean 的相关信息，包括属性、构造方法参数、依赖的 Bean 名称及是否单例、延迟加载等，它是实例化 Bean 的原材料，Spring 就是根据 BeanDefinition 中的信息实例化 Bean。

如果你从未了解过 Spring 源码，上面一段描述应该是无法理解的，但是我们大致可以知道它是用来描述 Bean 信息的，并且 Spring 可以通过它来创建实例 Bean。

另外，我不认为一上来详细的讲 BeanDefinition 的继承关系等等，你能有收获，大部分情况下还是一脸懵逼，我觉得最好的方式就是通过源码的方式一步一步的去了解它的组成关系或许更好。或者你可以看看这篇文章：[BeanDefinition 解析][BeanDefinition]

### 5. 源码分析 ###

对于源码分析的入口主要通过方法的调用来分析，其中可能涉及到一些不理解的类或者对象，可先不必纠结，我们先过一遍整体流程，由大到小。（源码中标注红框的方法为主要方法）

#### 5.1 加载配置文件入口 ####

在代码中很明显可以看到通过 `ClassPathXmlApplicationContext`去加载了spring.xml文件从而初始化容器，看看它的构造方法：

public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
        
    	this(new String[] {
        configLocation}, true, null);
    }

其中的 this 方法：

public ClassPathXmlApplicationContext(
    		String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
    		throws BeansException {
        
    	super(parent);
        //设置
    	setConfigLocations(configLocations);
    	if (refresh) {
        
    		refresh();
    	}
    }

#### 5.2 获取配置文件 ####

`setConfigLocations()`该方法的主要作用是获取配置文件位置信息。

public void setConfigLocations(@Nullable String... locations) {
        
    	if (locations != null) {
        
    		Assert.noNullElements(locations, "Config locations must not be null");
    		this.configLocations = new String[locations.length];
    		for (int i = 0; i < locations.length; i++) {
        
    			this.configLocations[i] = resolvePath(locations[i]).trim();
    		}
    	}
    	else {
        
    		this.configLocations = null;
    	}
    }

#### 5.3 refresh() ####

该方法是 spring 容器初始化的核心方法。是 spring 容器初始化的核心流程，它读取 spring xml 配置文件，并创建和初始化 beans，所以该方法**非常重要**。

public void refresh() throws BeansException, IllegalStateException {
        
    	synchronized (this.startupShutdownMonitor) {
        
    		// Prepare this context for refreshing.
            /*
             * 1、初始化做准备
             * 设置ApplicationContext中的一些标志位,如closed设为false,active设为true。
             * 校验添加了required标志的属性,如果他们为空,则抛出MissingRequiredPropertiesException异常。
             */
    		prepareRefresh();
            
            // 2、创建 BeanFactory,解析xml文件
    		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
            
    		// 3、给beanFactory设置一些属性值,如beanClassLoader
    		prepareBeanFactory(beanFactory);
    		try {
        
    			// Allows post-processing of the bean factory in context subclasses.
    			postProcessBeanFactory(beanFactory);
    			// Invoke factory processors registered as beans in the context.
    			invokeBeanFactoryPostProcessors(beanFactory);
    			// Register bean processors that intercept bean creation.
    			registerBeanPostProcessors(beanFactory);
    			// Initialize message source for this context.
    			initMessageSource();
    			// Initialize event multicaster for this context.
    			initApplicationEventMulticaster();
    			// Initialize other special beans in specific context subclasses.
    			onRefresh();
    			// Check for listener beans and register them.
    			registerListeners();
    			// 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();
    		}
    	}
    }

#### 5.4 加载配置文件 ####

在`refresh()`中通过`obtainFreshBeanFactory()`去解析 xml 文件，并且创建 BeanFactory。

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
        
    	refreshBeanFactory();
    	return getBeanFactory();
    }

这一步主要看`refreshBeanFactory()`中的`loadBeanDefinitions()`。

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

#### 5.5 创建 Xml 解析器 ####

![image-20211025112749864][]

#### 5.6 通过 Xml 解析器加载配置文件 ####

![image-20211025113346377][]

需要主要的是，在方法的跳转的时候有很多重载的`loadBeanDefinitions()`，可能在跳转过程中就晕了，但实际上我们只需要关注`XmlBeanDefinitionReader`中的即可，因为它的父类是`AbstractBeanDefinitionReader`，通过**模板方法模式**调用子类的方法，

![image-20211025114347471][]

#### 5.7 配置文件封装 Document 对象 ####

`Document` 接口表示整个 HTML 或 XML 文档。从概念上讲，它是文档树的根，并提供对文档数据的基本访问。也就是说我们的 xml 配置文件转为了一个 Java 中的对象。

![image-20211025114845362][]

#### 5.8 解析 Document 对象 ####

把 Document 对象解析为具体的 Element，并解析具体的标签。

![image-20211025115844318][]

#### 5.9 默认标签解析 ####

Spring 默认标签有四种：import、alias、bean和beans，如在 xml 文件中定义的 bean，这里我们主要看 bean 标签的解析。

![image-20211025151316848][]

bean 标签的解析方法如下：

![image-20211025151859305][]

正如上图所标记的，第一次出现了 **BeanDefinition** 的概念，从名字可以看出来它是用来描述或者说是定义 Bean 的（当然，这并不是一句话就能简单描述的，后续会主要来讲解）。而 **BeanDefinitionHolder** 用来保存 **BeanDefinition**，从源码中也可以看到：

![image-20211025152416910][]

然后，在去看对于 Bean 标签是如何解析的，我们在 xml 中一个标签是有很多属性的，如：

![image-20211025153903494][]

再去看看 `parseBeanDefinitionElement()`：

![image-20211025154846917][]

该方法并没有截取全部代码，我们要清楚一点，看源码并不是说每一行代码都需要弄清楚是干嘛的，比如上面方法我们知道它的返回对象为 **BeanDefinitionHolder** ，而 **BeanDefinitionHolder** 里面主要是包含了**BeanDefinition**等属性，所以我们要去看看这几个属性是创建的。

`beanName` 已经确定就是 Bean 标签 id 的值，`aliases`为 name 的值，再去看看**BeanDefinition**是如何定义的。

![image-20211025160038347][]

进入 `parseBeanDefinitionElement()`：

![image-20211025163435079][]

可以看到`createBeanDefinition(className, parent)`，该方法实际就是用来创建**BeanDefinition**的，只不过是其子类 **GenericBeanDefinition**：

![image-20211025160318562][]

创建的 **GenericBeanDefinition** 对于标签的解析主要是以下标签并设置，由此我们可以得出一个结论：

**Spring中每个 bean 实例，都有一个对应的 BeanDefinition 实例。这个 BeanDefinition 实例记录了该 bean 的各种属性信息，如 id、name 等等。**

![image-20211025163334703][]

对于上述中具体标签的使用和源码分析可参考：[bean标签的解析之简单子元素的解析][bean]

解析后封装的 `BeanDefinitionHolder`，里 面 放 置 `beanName` 和 `BeanDefinition` 对象，然后对`BeanDefinition` 对象进行缓存注册：

![image-20211025172105246][]

### 6. 总结 ###

本文主要讲的是对于 Spring 加载 xml 文件的默认标签，算是阅读源码的开胃菜，因为其中还涉及到**自定义标签的解析**以及**Bean的实例化**，这都会在接下来的文章中去讲解。

[Spring]: https://javatv.blog.csdn.net/article/details/120932765
[Spring_XML]: https://javatv.blog.csdn.net/article/details/120980758
[Spring 1]: https://javatv.blog.csdn.net/article/details/121000840
[Spring_Bean_invokeBeanFactoryPostProcessors]: https://javatv.blog.csdn.net/article/details/121060729
[image-20211021201814462]: https://img-blog.csdnimg.cn/img_convert/ac5a8b8ac4634f09705b6dcc99bec305.png
[image-20211021202633957]: https://img-blog.csdnimg.cn/img_convert/8af04950dd90421854456c466d6dfe2b.png
[image-20211021210402630]: https://img-blog.csdnimg.cn/img_convert/a0bd4e1a63a339bebd72ec37cecd1e23.png
[BeanDefinition]: https://www.cnblogs.com/loongk/p/12262101.html
[image-20211025112749864]: https://img-blog.csdnimg.cn/img_convert/dd4b0a89d78970c8c157fd3a180ce51e.png
[image-20211025113346377]: https://img-blog.csdnimg.cn/img_convert/fd5ef408ab28abdd546911ccb2fc6033.png
[image-20211025114347471]: https://img-blog.csdnimg.cn/img_convert/a65a96c490d6103efdc4e513060ea5d6.png
[image-20211025114845362]: https://img-blog.csdnimg.cn/img_convert/177d456ca170cf71d38bb8aa1814fab2.png
[image-20211025115844318]: https://img-blog.csdnimg.cn/img_convert/31d27f91c99f75fc5b49bb09100616ab.png
[image-20211025151316848]: https://img-blog.csdnimg.cn/img_convert/9c9469a3f42fbc337d9e7c9ed7d70711.png
[image-20211025151859305]: https://img-blog.csdnimg.cn/img_convert/95cf3c9498ac4913407a611b02d8cd96.png
[image-20211025152416910]: https://img-blog.csdnimg.cn/img_convert/f5c281301d91b8c4a7d64d9b8374f1bb.png
[image-20211025153903494]: https://img-blog.csdnimg.cn/img_convert/95143a02c74ebca940185634ba6de17f.png
[image-20211025154846917]: https://img-blog.csdnimg.cn/img_convert/91a29c9f4fa0fda180dcba8b4b67bae8.png
[image-20211025160038347]: https://img-blog.csdnimg.cn/img_convert/48004ec5683b413a51c9fb657ceefa9f.png
[image-20211025163435079]: https://img-blog.csdnimg.cn/img_convert/38707c6c3bef0e8612f573d10aa800fa.png
[image-20211025160318562]: https://img-blog.csdnimg.cn/img_convert/3bef8d84d309837e919de220eed45019.png
[image-20211025163334703]: https://img-blog.csdnimg.cn/img_convert/2c39897256c274bf024951e0278b7690.png
[bean]: https://blog.csdn.net/Bronze5/article/details/100751467
[image-20211025172105246]: https://img-blog.csdnimg.cn/img_convert/c53da1c026183ce604b18d5a2231cd0b.png