《SpringBoot启动流程二》：七千字源码分析SpringApplication构造阶段

﹏ヽ暗。殇╰゛Y 2023-09-29 13:56 13阅读 0赞

#### 文章目录 ####

*  一、前言
 *  二、初始化SpringApplication
 *   *  1、primarySources参数
     *  2、SpringApplication构造过程
     *   *  1）推断Web应用类型
         *  2）加载Spring应用上下文初始化器ApplicationContextInitializer
         *  3）加载Spring事件应用监听器ApplicationListener
         *  4）推断应用引导类

## 一、前言 ##

上文聊了 SpringBoot如何加载并处理spring.factories文件中的信息。本文我们接着聊在构建SpringApplication的过程中都做了什么？加载spring.factories文件中的哪些信息？

注：Spring Boot版本：2.3.7

## 二、初始化SpringApplication ##

![在这里插入图片描述][8b8d7811e07b4dd69d125b6299443259.png]

先看一个简单的SpringBoot 启动类：

@SpringBootApplication
    public class StartApplication {
        
        public static void main(String[] args) {
        
            SpringApplication.run(StartApplication.class, args);
    }

根据SpringApplication的实现，当前启动类`StartApplication`的引导语句`SpringApplication.run(StartApplication.class, args);`经过两层深入，会进入到`new SpringApplication(primarySources).run(args)`。

![在这里插入图片描述][6e732510b99348e48f61275c706fcd24.png]

这里需要Class类型的primarySources参数，下面我先看一下这个参数有什么实际意义？

### 1、primarySources参数 ###

primarySources参数实际为Spring Boot应用上下文的Configuration Class。换言之，Spring Boot应用上下文的Configuration Class也不一定非得是引导类（启动类），我们可以把Configuration Class抽出来，使用@EnableAutoConfiguration注解标注，然后将引导类（启动类）中的primarySources参数设置为`抽出来的Configuration Class`。

示例如下：

**1> 自定义 Configuration Class：**

@Configuration
    @EnableAutoConfiguration
    public class MySpringApplicationConfiguration {
        
    }

**2> 修改引导类（启动类）：**

*  引导类中不再需要添加`@SpringBootApplication`注解

public class StartApplication {
        
        public static void main(String[] args) {
        
            SpringApplication.run(MySpringApplicationConfiguration.class, args);
    }

### 2、SpringApplication构造过程 ###

已知SpringApplication\#run(Class, String…)方法的执行会伴随SpringApplication对象的初始化，其构造函数为：SpringApplication(Class…)  
![在这里插入图片描述][82b789b48a50403192bc186d23cac2a8.png]  
**具体操作包括：**

> 1.  首先初始化资源加载器，默认为null；断言判断主要资源类不能为null，否者报错。
> 2.  然后将主资源类primarySources存储到SpringApplication对象Set类型的`primarySources`属性中。
> 3.  推断当前 WEB 应用类型，一共有三种：NONE,SERVLET,REACTIVE；默认是SERVLET。
> 4.  加载Spring应用上下文初始化器：从"META-INF/spring.factories"文件中读取`ApplicationContextInitializer`类的实例名称集合，然后进行Set去重、利用反射实例化对象，最后按照Order排序后，赋值到SpringApplication的List类型的initializers属性上，一共7个。
> 5.  加载Spring应用事件监听器：从"META-INF/spring.factories"文件中读取`ApplicationListener`类的实例名称集合，然后进行Set去重、利用反射实例化对象，最后按照Order排序后，赋值到SpringApplication的List类型的listeners属性上，一共11个。
> 6.  推断主入口应用类：通过当前调用栈的解析，获取Main方法所在类，并赋值给SpringApplication的`mainApplicationClass`属性。

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
        
    		// 初始化资源加载器，默认为null
    		this.resourceLoader = resourceLoader;
    		// 断言 判断主要资源类不能为 null，否则报错
    		Assert.notNull(primarySources, "PrimarySources must not be null");
    		// 初始化主要资源类集合并去重
    		this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
    		// 推断当前 WEB 应用类型，一共有三种：NONE,SERVLET,REACTIVE
    		this.webApplicationType = WebApplicationType.deduceFromClasspath();
    		// 加载并设置Spring应用上下文初始化器, 从"META-INF/spring.factories"读取ApplicationContextInitializer类的实例名称集合，
    		// 并进行set去重，然后利用反射实例化对象，最后进行Order排序。（一共7个）
    		setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
    		// 加载并设置Spring应用事件监听器,从"META-INF/spring.factories"读取ApplicationListener类的实例名称集合，
    		// 并进行set去重，然后利用反射实例化对象，最后进行Order排序。（一共11个）
    		setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
    		// 推断主应用程序类，通过当前调用栈，获取Main方法所在类，并赋值给mainApplicationClass
    		this.mainApplicationClass = deduceMainApplicationClass();
    	}

下面具体看一下是怎么推断Web应用类型的？怎么加载Spring应用上下文初始化器、怎么加载Spring应用事件监听器的？又是怎么推断`应用引导类`的？

#### 1）推断Web应用类型 ####

this.webApplicationType = WebApplicationType.deduceFromClasspath();

因为Web应用类型可能在SpringApplication构造后及run方法之前，再通过`setWebApplicatioinType(WebApplicationType)`方法调整；又在推断Web应用类型的过程中，由于当前Spring应用上下文尚未准备，所以采用检查当前ClassLoader下`基准Class`的存在性来推断Web应用类型。

public enum WebApplicationType {
        
    
    	NONE,
    	SERVLET,
    	REACTIVE;
    
    	private static final String[] SERVLET_INDICATOR_CLASSES = {
         "javax.servlet.Servlet",
    			"org.springframework.web.context.ConfigurableWebApplicationContext" };
    
    	private static final String WEBMVC_INDICATOR_CLASS = "org.springframework.web.servlet.DispatcherServlet";
    
    	private static final String WEBFLUX_INDICATOR_CLASS = "org.springframework.web.reactive.DispatcherHandler";
    
    	private static final String JERSEY_INDICATOR_CLASS = "org.glassfish.jersey.servlet.ServletContainer";
        
        ....
    
    	static WebApplicationType deduceFromClasspath() {
        
    		// 1. 如果`DispatcherHandler`存在，并且`DispatcherServlet`和`ServletContainer`不存在时，Web应用类型为REACTIVE；
    		if (ClassUtils.isPresent(WEBFLUX_INDICATOR_CLASS, null) && !ClassUtils.isPresent(WEBMVC_INDICATOR_CLASS, null)
    				&& !ClassUtils.isPresent(JERSEY_INDICATOR_CLASS, null)) {
        
    			return WebApplicationType.REACTIVE;
    		}
    		// 2. 如果`Servlet`和`ConfigurableWebApplicationContext`不存在，则当前应用为非Web引应用，即NONE。
    		for (String className : SERVLET_INDICATOR_CLASSES) {
        
    			if (!ClassUtils.isPresent(className, null)) {
        
    				return WebApplicationType.NONE;
    			}
    		}
    		// 3.当Spring WebFlux和Spring Web MVC同时存在时，Web应用依旧是SERVLET。
    		return WebApplicationType.SERVLET;
    	}
    	}
        ....
    }

WEB 应用类型，一共有三种：NONE，SERVLET，REACTIVE。

`deduceFromClasspath()`方法利用ClassUtils.isPresent(String, ClassLoader)方法依次判断`reactive.DispatcherHandler`、`ConfigurableWebApplicationContext`、`Servlet`、`servlet.DispatcherServlet`的存在性组合情况，从而判断Web 引用类型，具体逻辑如下：

> 1.  如果`DispatcherHandler`存在，并且`DispatcherServlet`和`ServletContainer`不存在时，即：Spring Boot仅依赖WebFlux时，Web应用类型为REACTIVE；
> 2.  如果`Servlet`和`ConfigurableWebApplicationContext`不存在，则当前应用为非Web应用，即NONE。因为这两个API是Spring Web MVC必须的依赖。
> 3.  当Spring WebFlux和Spring Web MVC同时存在时，Web应用类型依旧是SERVLET。

当`deduceFromClasspath()`方法执行完毕后，SpringApplication的构造进入“加载Spring应用上下文初始化器、Spring事件监听器”过程。

#### 2）加载Spring应用上下文初始化器ApplicationContextInitializer ####

setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));

**这个过程包括两个动作：**

> **1>** `getSpringFactoriesInstances(ApplicationContextInitializer.class)`从"META-INF/spring.factories"文件中读取`ApplicationContextInitializer`类的实例名称集合，然后进行Set去重、利用反射实例化对象，最后按照Order排序。  
> **2>** `setInitializers(Collection)`将Collection赋值到SpringApplication的List类型的initializers属性上，一共7个。

getSpringFactoriesInstances(Class)在前一篇博文中详细聊过，移步：[《SpringBoot启动流程一》：万字debug梳理SpringBoot如何加载并处理META-INF/spring.factories文件中的信息][SpringBoot_debug_SpringBoot_META-INF_spring.factories]。

第二步单纯的赋值：

public void setInitializers(Collection<? extends ApplicationContextInitializer<?>> initializers) {
        
    	this.initializers = new ArrayList<>(initializers);
    }

#### 3）加载Spring事件应用监听器ApplicationListener ####

setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));

**这个过程和加载Spring应用上下文初始化器ApplicationContextInitializer一样（区别在于这里不再直接从spring.factories文件中获取内容，而是走cache（`MultiValueMap<String, String>`）缓存），也是包括两个动作（第一个动作一样）。**

第二步 `setListeners(Collection)`将Collection赋值到SpringApplication的List类型的listeners属性上，一共11个。

public void setListeners(Collection<? extends ApplicationListener<?>> listeners) {
        
    	this.listeners = new ArrayList<>(listeners);
    }

**加载结果如下：**  
![在这里插入图片描述][ad307cc7311042ac9f61c6ed6d4e2749.png]

#### 4）推断应用引导类 ####

this.mainApplicationClass = deduceMainApplicationClass();

推断应用引导类是SpringApplication构建过程的最后一步，其执行方法`deduceMainApplicationClass()`：

private Class<?> deduceMainApplicationClass() {
        
    	try {
        
    		StackTraceElement[] stackTrace = new RuntimeException().getStackTrace();
    		for (StackTraceElement stackTraceElement : stackTrace) {
        
    			if ("main".equals(stackTraceElement.getMethodName())) {
        
    				return Class.forName(stackTraceElement.getClassName());
    			}
    		}
    	}
    	catch (ClassNotFoundException ex) {
        
    		// Swallow and continue
    	}
    	return null;
    }

该方法根据当前线程执行栈来判断其栈中哪个类包含main方法，然后将找到的类名通过反射返回Class对象。

![在这里插入图片描述][a806b44e5d2944c78554b9ad5fce93ce.png]

**至此，在SpringApplication构造过程中，SpringApplication属性primarySources、webApplicationType、initializers、listeners 和 mainApplicationClass都被初始化了，下一篇文博文继续聊SpringApplication的准备阶段。即：从run(String…)方法调用开始 到 refreshContext(ConfigurableApplicationContext调用前)**

[8b8d7811e07b4dd69d125b6299443259.png]: https://img-blog.csdnimg.cn/8b8d7811e07b4dd69d125b6299443259.png
[6e732510b99348e48f61275c706fcd24.png]: https://img-blog.csdnimg.cn/6e732510b99348e48f61275c706fcd24.png
[82b789b48a50403192bc186d23cac2a8.png]: https://img-blog.csdnimg.cn/82b789b48a50403192bc186d23cac2a8.png
[SpringBoot_debug_SpringBoot_META-INF_spring.factories]: https://blog.csdn.net/Saintmm/article/details/124673268
[ad307cc7311042ac9f61c6ed6d4e2749.png]: https://img-blog.csdnimg.cn/ad307cc7311042ac9f61c6ed6d4e2749.png
[a806b44e5d2944c78554b9ad5fce93ce.png]: https://img-blog.csdnimg.cn/a806b44e5d2944c78554b9ad5fce93ce.png