Spring Boot 2.x 启动全过程源码分析（上）入口类剖析

旧城等待， 2022-02-27 10:14 159阅读 0赞

## Spring Boot 2.x 启动全过程源码分析（上）入口类剖析 ##

原创： 不羁码农 Java技术栈  **Java技术栈**

微信号 javastack

功能介绍 专注分享Java技术干货，包括多线程、JVM、Spring Boot、Spring Cloud、Intellij IDEA、Dubbo、Zookeeper、Redis、架构设计、微服务、消息队列、Git、面试题、程序员攻略、最新动态等。

*2018-08-04*

![640_wxfrom_5_wx_lazy_1_wx_co_1][]

Java技术栈

www.javastack.cn

优秀的Java技术公众号

Spring Boot 的应用教程我们已经分享过很多了，今天来通过源码来分析下它的启动过程，探究下 Spring Boot 为什么这么简便的奥秘。

本篇基于 **Spring Boot 2.0.3** 版本进行分析，阅读本文需要有一些 Java 和 Spring 框架基础，**如果还不知道 Spring Boot 是什么，建议先看下我们的 Spring Boot 教程**。

### Spring Boot 的入口类 ###

1.  `@SpringBootApplication`
2.  `public class SpringBootBestPracticeApplication {`
3.   
4.  `   public static void main(String[] args) {`
5.  `       SpringApplication.run(SpringBootBestPracticeApplication.class, args);`
6.  `   }`
7.   
8.  `}`

做过 Spring Boot 项目的都知道，上面是 Spring Boot 最简单通用的入口类。入口类的要求是最顶层包下面第一个含有 main 方法的类，使用注解 `@SpringBootApplication` 来启用 Spring Boot 特性，使用 `SpringApplication.run` 方法来启动 Spring Boot 项目。

来看一下这个类的 `run` 方法调用关系源码：

1.  `public static ConfigurableApplicationContext run(Class<?> primarySource,`
2.  `       String... args) {`
3.  `   return run(new Class<?>[] { primarySource }, args);`
4.  `}`
5.   
6.  `public static ConfigurableApplicationContext run(Class<?>[] primarySources,`
7.  `       String[] args) {`
8.  `   return new SpringApplication(primarySources).run(args);`
9.  `}`

第一个参数 `primarySource`：加载的主要资源类

第二个参数 `args`：传递给应用的应用参数

先用主要资源类来实例化一个 `SpringApplication` 对象，再调用这个对象的 `run` 方法，所以我们分两步来分析这个启动源码。

### SpringApplication 的实例化过程 ###

![640_wxfrom_5_wx_lazy_1_wx_co_1 1][]

接着上面的 `SpringApplication` 构造方法进入以下源码：

1.  `public SpringApplication(Class<?>... primarySources) {`
2.  `   this(null, primarySources);`
3.  `}`
4.   
5.  `public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {`
6.  `   // 1、资源初始化资源加载器为 null`
7.  `   this.resourceLoader = resourceLoader;`
8.   
9.  `   // 2、断言主要加载资源类不能为 null，否则报错`
10. `   Assert.notNull(primarySources, "PrimarySources must not be null");`
11.  
12. `   // 3、初始化主要加载资源类集合并去重`
13. `   this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));`
14.  
15. `   // 4、推断当前 WEB 应用类型`
16. `   this.webApplicationType = deduceWebApplicationType();`
17.  
18. `   // 5、设置应用上线文初始化器`
19. `   setInitializers((Collection) getSpringFactoriesInstances(`
20. `           ApplicationContextInitializer.class));      `
21.  
22. `   // 6、设置监听器            `
23. `   setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));`
24.  
25. `   // 7、推断主入口应用类`
26. `   this.mainApplicationClass = deduceMainApplicationClass();`
27. `}`

可知这个构造器类的初始化包括以下 7 个过程。

1、资源初始化资源加载器为 null

1.  `this.resourceLoader = resourceLoader;`

2、断言主要加载资源类不能为 null，否则报错

1.  `Assert.notNull(primarySources, "PrimarySources must not be null");`

3、初始化主要加载资源类集合并去重

1.  `this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));`

4、推断当前 WEB 应用类型

1.  `this.webApplicationType = deduceWebApplicationType();`

来看下 `deduceWebApplicationType` 方法和相关的源码：

1.  `private WebApplicationType deduceWebApplicationType() {`
2.  `   if (ClassUtils.isPresent(REACTIVE_WEB_ENVIRONMENT_CLASS, null)`
3.  `           && !ClassUtils.isPresent(MVC_WEB_ENVIRONMENT_CLASS, null)) {`
4.  `       return WebApplicationType.REACTIVE;`
5.  `   }`
6.  `   for (String className : WEB_ENVIRONMENT_CLASSES) {`
7.  `       if (!ClassUtils.isPresent(className, null)) {`
8.  `           return WebApplicationType.NONE;`
9.  `       }`
10. `   }`
11. `   return WebApplicationType.SERVLET;`
12. `}`
13.  
14. `private static final String REACTIVE_WEB_ENVIRONMENT_CLASS = "org.springframework."`
15. `       + "web.reactive.DispatcherHandler";`
16.  
17. `private static final String MVC_WEB_ENVIRONMENT_CLASS = "org.springframework."`
18. `       + "web.servlet.DispatcherServlet";`
19.  
20. `private static final String[] WEB_ENVIRONMENT_CLASSES = { "javax.servlet.Servlet",`
21. `           "org.springframework.web.context.ConfigurableWebApplicationContext" };      `
22.  
23. `public enum WebApplicationType {`
24.  
25. `   /**`
26. `    * 非 WEB 项目`
27. `    */`
28. `   NONE,`
29.  
30. `   /**`
31. `    * SERVLET WEB 项目`
32. `    */`
33. `   SERVLET,`
34.  
35. `   /**`
36. `    * 响应式 WEB 项目`
37. `    */`
38. `   REACTIVE`
39.  
40. `}`

这个就是根据类路径下是否有对应项目类型的类推断出不同的应用类型。

5、设置应用上线文初始化器

1.  `setInitializers((Collection) getSpringFactoriesInstances(`
2.  `           ApplicationContextInitializer.class));`

**`ApplicationContextInitializer` 的作用是什么？源码如下。**

1.  `public interface ApplicationContextInitializer<C extends ConfigurableApplicationContext> {`
2.   
3.  `   /**`
4.  `    * Initialize the given application context.`
5.  `    * @param applicationContext the application to configure`
6.  `    */`
7.  `   void initialize(C applicationContext);`
8.   
9.  `}`

用来初始化指定的 Spring 应用上下文，如注册属性资源、激活 Profiles 等。

来看下 `setInitializers` 方法源码，其实就是初始化一个 `ApplicationContextInitializer` 应用上下文初始化器实例的集合。

1.  `public void setInitializers(`
2.  `       Collection<? extends ApplicationContextInitializer<?>> initializers) {`
3.  `   this.initializers = new ArrayList<>();`
4.  `   this.initializers.addAll(initializers);`
5.  `}`

再来看下这个初始化 `getSpringFactoriesInstances` 方法和相关的源码：

1.  `private <T> Collection<T> getSpringFactoriesInstances(Class<T> type) {`
2.  `   return getSpringFactoriesInstances(type, new Class<?>[] {});`
3.  `}`
4.   
5.  `private <T> Collection<T> getSpringFactoriesInstances(Class<T> type,`
6.  `       Class<?>[] parameterTypes, Object... args) {`
7.  `   ClassLoader classLoader = Thread.currentThread().getContextClassLoader();`
8.  `   // Use names and ensure unique to protect against duplicates`
9.  `   Set<String> names = new LinkedHashSet<>(`
10. `           SpringFactoriesLoader.loadFactoryNames(type, classLoader));`
11. `   List<T> instances = createSpringFactoriesInstances(type, parameterTypes,`
12. `           classLoader, args, names);`
13. `   AnnotationAwareOrderComparator.sort(instances);`
14. `   return instances;`
15. `}`

设置应用上下文初始化器可分为以下 5 个步骤。

**5.1）获取当前线程上下文类加载器**

1.  `ClassLoader classLoader = Thread.currentThread().getContextClassLoader();`

**5.2）获取 `ApplicationContextInitializer` 的实例名称集合并去重**

1.  `Set<String> names = new LinkedHashSet<>(`
2.  `               SpringFactoriesLoader.loadFactoryNames(type, classLoader));`

`loadFactoryNames` 方法相关的源码如下：

1.  `public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {`
2.  `   String factoryClassName = factoryClass.getName();`
3.  `   return loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());`
4.  `}`
5.   
6.  `public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";`
7.   
8.  `private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {`
9.  `   MultiValueMap<String, String> result = cache.get(classLoader);`
10. `   if (result != null) {`
11. `       return result;`
12. `   }`
13.  
14. `   try {`
15. `       Enumeration<URL> urls = (classLoader != null ?`
16. `               classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :`
17. `               ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));`
18. `       result = new LinkedMultiValueMap<>();`
19. `       while (urls.hasMoreElements()) {`
20. `           URL url = urls.nextElement();`
21. `           UrlResource resource = new UrlResource(url);`
22. `           Properties properties = PropertiesLoaderUtils.loadProperties(resource);`
23. `           for (Map.Entry<?, ?> entry : properties.entrySet()) {`
24. `               List<String> factoryClassNames = Arrays.asList(`
25. `                       StringUtils.commaDelimitedListToStringArray((String) entry.getValue()));`
26. `               result.addAll((String) entry.getKey(), factoryClassNames);`
27. `           }`
28. `       }`
29. `       cache.put(classLoader, result);`
30. `       return result;`
31. `   }`
32. `   catch (IOException ex) {`
33. `       throw new IllegalArgumentException("Unable to load factories from location [" +`
34. `               FACTORIES_RESOURCE_LOCATION + "]", ex);`
35. `   }`
36. `}`

根据类路径下的 `META-INF/spring.factories` 文件解析并获取 `ApplicationContextInitializer` 接口的所有配置的类路径名称。

`spring-boot-autoconfigure-2.0.3.RELEASE.jar!/META-INF/spring.factories` 的初始化器相关配置内容如下：

1.  `# Initializers`
2.  `org.springframework.context.ApplicationContextInitializer=\`
3.  `org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,\`
4.  `org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener`

**5.3）根据以上类路径创建初始化器实例列表**

1.  `List<T> instances = createSpringFactoriesInstances(type, parameterTypes,`
2.  `               classLoader, args, names);`
3.   
4.  `private <T> List<T> createSpringFactoriesInstances(Class<T> type,`
5.  `       Class<?>[] parameterTypes, ClassLoader classLoader, Object[] args,`
6.  `       Set<String> names) {`
7.  `   List<T> instances = new ArrayList<>(names.size());`
8.  `   for (String name : names) {`
9.  `       try {`
10. `           Class<?> instanceClass = ClassUtils.forName(name, classLoader);`
11. `           Assert.isAssignable(type, instanceClass);`
12. `           Constructor<?> constructor = instanceClass`
13. `                   .getDeclaredConstructor(parameterTypes);`
14. `           T instance = (T) BeanUtils.instantiateClass(constructor, args);`
15. `           instances.add(instance);`
16. `       }`
17. `       catch (Throwable ex) {`
18. `           throw new IllegalArgumentException(`
19. `                   "Cannot instantiate " + type + " : " + name, ex);`
20. `       }`
21. `   }`
22. `   return instances;`
23. `}`

**5.4）初始化器实例列表排序**

1.  `AnnotationAwareOrderComparator.sort(instances);`

**5.5）返回初始化器实例列表**

1.  `return instances;`

6、设置监听器

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

**`ApplicationListener` 的作用是什么？源码如下。**

1.  `@FunctionalInterface`
2.  `public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {`
3.   
4.  `   /**`
5.  `    * Handle an application event.`
6.  `    * @param event the event to respond to`
7.  `    */`
8.  `   void onApplicationEvent(E event);`
9.   
10. `}`

看源码，这个接口继承了 JDK 的 `java.util.EventListener` 接口，实现了观察者模式，它一般用来定义感兴趣的事件类型，事件类型限定于 ApplicationEvent 的子类，这同样继承了 JDK 的 `java.util.EventObject` 接口。

设置监听器和设置初始化器调用的方法是一样的，只是传入的类型不一样，设置监听器的接口类型为： `getSpringFactoriesInstances`，对应的 `spring-boot-autoconfigure-2.0.3.RELEASE.jar!/META-INF/spring.factories` 文件配置内容请见下方。

1.  `# Application Listeners`
2.  `org.springframework.context.ApplicationListener=\`
3.  `org.springframework.boot.autoconfigure.BackgroundPreinitializer`

可以看出目前只有一个 `BackgroundPreinitializer` 监听器。

7、推断主入口应用类

1.  `this.mainApplicationClass = deduceMainApplicationClass();`
2.   
3.  `private Class<?> deduceMainApplicationClass() {`
4.  `   try {`
5.  `       StackTraceElement[] stackTrace = new RuntimeException().getStackTrace();`
6.  `       for (StackTraceElement stackTraceElement : stackTrace) {`
7.  `           if ("main".equals(stackTraceElement.getMethodName())) {`
8.  `               return Class.forName(stackTraceElement.getClassName());`
9.  `           }`
10. `       }`
11. `   }`
12. `   catch (ClassNotFoundException ex) {`
13. `       // Swallow and continue`
14. `   }`
15. `   return null;`
16. `}`

这个推断入口应用类的方式有点特别，通过构造一个运行时异常，再遍历异常栈中的方法名，获取方法名为 main 的栈帧，从来得到入口类的名字再返回该类。

### 总结 ###

源码分析内容有点多，也很麻烦，本章暂时分析到 `SpringApplication` 构造方法的初始化流程，**下章再继续分析其** **`run` 方法，作者很快写完过两天就发布，扫码关注下面的公众号** **"Java技术栈"** **即可获取推送更新。**

**源码分析不易，点赞 + 转发支持一下吧！**

往期干货推荐

**1.** [Spring Boot 2.x 新特性总结及迁移指南][Spring Boot 2.x]

**2. **[Spring Boot 集成 Mybatis 实现双数据源][Spring Boot _ Mybatis]

**3.** [Spring Boot 核心配置文件详解][Spring Boot]

**4.** [Spring Boot 单元测试详解+实战教程][Spring Boot 1]

**5.** [Spring Boot 自动配置原理、实战][Spring Boot 2]

[640_wxfrom_5_wx_lazy_1_wx_co_1]: /images/20220227/b332c179323943a68654977315b584f2.png
[640_wxfrom_5_wx_lazy_1_wx_co_1 1]: /images/20220227/4b82914821a64e728a7b7cb2578b2bb0.png
[Spring Boot 2.x]: http://mp.weixin.qq.com/s?__biz=MzI3ODcxMzQzMw==&mid=2247486395&idx=1&sn=acad48d7672a796db39fa2d09dc59caf&chksm=eb538e8ddc24079b04e123ab5651509ad23a5803eebb5a57b171748e562509fabee0c447ab55&scene=21#wechat_redirect
[Spring Boot _ Mybatis]: http://mp.weixin.qq.com/s?__biz=MzI3ODcxMzQzMw==&mid=2247486113&idx=2&sn=10febe8f38ef16e4b91328f45c6f4539&chksm=eb538f97dc240681755ef8d41d401cb3577f6695369030fdd464bb6e036b64663e581b895d2f&scene=21#wechat_redirect
[Spring Boot]: http://mp.weixin.qq.com/s?__biz=MzI3ODcxMzQzMw==&mid=2247486541&idx=2&sn=436ab454a6367fdc33912162855c02c7&chksm=eb53897bdc24006d4259ae73290ba17378b47ed0de2ec033846e272a80cceb969c11aa1230f7&scene=21#wechat_redirect
[Spring Boot 1]: http://mp.weixin.qq.com/s?__biz=MzI3ODcxMzQzMw==&mid=2247486167&idx=2&sn=83ca604b6154250f78f4ab3ef32f498c&chksm=eb538fe1dc2406f76848526c5b843cffb163902879a500f3b3e6acd5c3dc04f2e911db77b426&scene=21#wechat_redirect
[Spring Boot 2]: http://mp.weixin.qq.com/s?__biz=MzI3ODcxMzQzMw==&mid=2247484365&idx=1&sn=a4ab1d977d6b03bf122b4d596d7ee1ab&chksm=eb5386fbdc240fed381c1739255ad85912fc59282986fa050b915df63bf2e3f5af6e1e3fbfac&scene=21#wechat_redirect