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

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.    public static void main(String[] args) {

4.        SpringApplication.run(SpringBootBestPracticeApplication.class, args);

5.    }

6. }

做过 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. public static ConfigurableApplicationContext run(Class<?>[] primarySources,

6.        String[] args) {

7.    return new SpringApplication(primarySources).run(args);

8. }

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

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

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

SpringApplication 的实例化过程

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

1. public SpringApplication(Class<?>... primarySources) {

2.    this(null, primarySources);

3. }

4. public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {

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

6.    this.resourceLoader = resourceLoader;

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

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

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

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

11.    // 4、推断当前 WEB 应用类型

12.    this.webApplicationType = deduceWebApplicationType();

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

14.    setInitializers((Collection) getSpringFactoriesInstances(

15.            ApplicationContextInitializer.class));      

16.    // 6、设置监听器            

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

18.    // 7、推断主入口应用类

19.    this.mainApplicationClass = deduceMainApplicationClass();

20. }

可知这个构造器类的初始化包括以下 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. private static final String REACTIVE_WEB_ENVIRONMENT_CLASS = "org.springframework."

14.        + "web.reactive.DispatcherHandler";

15. private static final String MVC_WEB_ENVIRONMENT_CLASS = "org.springframework."

16.        + "web.servlet.DispatcherServlet";

17. private static final String[] WEB_ENVIRONMENT_CLASSES = { "javax.servlet.Servlet",

18.            "org.springframework.web.context.ConfigurableWebApplicationContext" };      

19. public enum WebApplicationType {

20.    /**

21.     * 非 WEB 项目

22.     */

23.    NONE,

24.    /**

25.     * SERVLET WEB 项目

26.     */

27.    SERVLET,

28.    /**

29.     * 响应式 WEB 项目

30.     */

31.    REACTIVE

32. }

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

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

1. setInitializers((Collection) getSpringFactoriesInstances(

2.            ApplicationContextInitializer.class));

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

1. public interface ApplicationContextInitializer<C extends ConfigurableApplicationContext> {

2.    /**

3.     * Initialize the given application context.

4.     * @param applicationContext the application to configure

5.     */

6.    void initialize(C applicationContext);

7. }

用来初始化指定的 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. private <T> Collection<T> getSpringFactoriesInstances(Class<T> type,

5.        Class<?>[] parameterTypes, Object... args) {

6.    ClassLoader classLoader = Thread.currentThread().getContextClassLoader();

7.    // Use names and ensure unique to protect against duplicates

8.    Set<String> names = new LinkedHashSet<>(

9.            SpringFactoriesLoader.loadFactoryNames(type, classLoader));

10.    List<T> instances = createSpringFactoriesInstances(type, parameterTypes,

11.            classLoader, args, names);

12.    AnnotationAwareOrderComparator.sort(instances);

13.    return instances;

14. }

设置应用上下文初始化器可分为以下 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. public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";

6. private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {

7.    MultiValueMap<String, String> result = cache.get(classLoader);

8.    if (result != null) {

9.        return result;

10.    }

11.    try {

12.        Enumeration<URL> urls = (classLoader != null ?

13.                classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :

14.                ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));

15.        result = new LinkedMultiValueMap<>();

16.        while (urls.hasMoreElements()) {

17.            URL url = urls.nextElement();

18.            UrlResource resource = new UrlResource(url);

19.            Properties properties = PropertiesLoaderUtils.loadProperties(resource);

20.            for (Map.Entry<?, ?> entry : properties.entrySet()) {

21.                List<String> factoryClassNames = Arrays.asList(

22.                        StringUtils.commaDelimitedListToStringArray((String) entry.getValue()));

23.                result.addAll((String) entry.getKey(), factoryClassNames);

24.            }

25.        }

26.        cache.put(classLoader, result);

27.        return result;

28.    }

29.    catch (IOException ex) {

30.        throw new IllegalArgumentException("Unable to load factories from location [" +

31.                FACTORIES_RESOURCE_LOCATION + "]", ex);

32.    }

33. }

根据类路径下的 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. private <T> List<T> createSpringFactoriesInstances(Class<T> type,

4.        Class<?>[] parameterTypes, ClassLoader classLoader, Object[] args,

5.        Set<String> names) {

6.    List<T> instances = new ArrayList<>(names.size());

7.    for (String name : names) {

8.        try {

9.            Class<?> instanceClass = ClassUtils.forName(name, classLoader);

10.            Assert.isAssignable(type, instanceClass);

11.            Constructor<?> constructor = instanceClass

12.                    .getDeclaredConstructor(parameterTypes);

13.            T instance = (T) BeanUtils.instantiateClass(constructor, args);

14.            instances.add(instance);

15.        }

16.        catch (Throwable ex) {

17.            throw new IllegalArgumentException(

18.                    "Cannot instantiate " + type + " : " + name, ex);

19.        }

20.    }

21.    return instances;

22. }

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.     * Handle an application event.

5.     * @param event the event to respond to

6.     */

7.    void onApplicationEvent(E event);

8. }

看源码，这个接口继承了 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. private Class<?> deduceMainApplicationClass() {

3.    try {

4.        StackTraceElement[] stackTrace = new RuntimeException().getStackTrace();

5.        for (StackTraceElement stackTraceElement : stackTrace) {

6.            if ("main".equals(stackTraceElement.getMethodName())) {

7.                return Class.forName(stackTraceElement.getClassName());

8.            }

9.        }

10.    }

11.    catch (ClassNotFoundException ex) {

12.        // Swallow and continue

13.    }

14.    return null;

15. }

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

总结

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

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

往期干货推荐

Java技术栈 • 长按关注