前言

        最近在学习Spring Boot相关的课程，过程中以笔记的形式记录下来，方便以后回忆，同时也在这里和大家探讨探讨，文章中有漏的或者有补充的、错误的都希望大家能够及时提出来，本人在此先谢谢了！

开始之前呢，希望大家带着几个问题去学习：
1、Spring Boot SpringApplication是什么？
2、怎么实现的？
3、优点和缺点是什么？
4、是怎么和 Spring 关联起来的？
这是对自我的提问，我认为带着问题去学习，是一种更好的学习方式，有利于加深理解。好了，接下来进入主题。

1、起源

        上篇文章我们讲了 Spring Boot 自动装配相关的知识，但还是不知道 Spring Boot 为什么运行 SpringApplication.run() 就可以启动，它是怎么和 Spring 应用上下文联系起来的，以及如何使用 SpringApplication驱动 Spring 应用。接下来就展开对 SpringApplication 的讨论。

注：本篇文章所用到的 Spring Boot版本是 2.1.6.BUILD-SNAPSHOT

2、SpringApplication 准备阶段

        SpringApplication 在运行前做了一系列的准备工作，如：推断 Web 应用类型、加载 Spring 的上下文初始化器和事件监听器以及配置默认属性等。接下来，就通过源码的方式进行学习。

先来看看启动类：

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

@SpringBootApplication 该注解上篇文章说过，是进行自动装配以及包扫描使用，这里不再赘述，我们主要关注 run 方法：

public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
    return run(new Class<?>[] { primarySource }, args);
}

public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
    return new SpringApplication(primarySources).run(args);
}

可以看到， 通过入参 primarySources 构造 SpringApplication 类，然后在调用 run 方法，其中，准备阶段的工作皆在 SpringApplication 的构造器中处理：

public class SpringApplication {

    ...

    private Set<Class<?>> primarySources;
    
    private WebApplicationType webApplicationType;
    
    private List<ApplicationContextInitializer<?>> initializers;
    
    private List<ApplicationListener<?>> listeners;
    
    private Class<?> mainApplicationClass;

    public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
    
        // resourceLoader 主要用来获取 Resource 及 ClassLoader。这里值为 null
        this.resourceLoader = resourceLoader;
        
        // 断言主要加载资源类不能为 null，否则报错
        Assert.notNull(primarySources, "PrimarySources must not be null");
        
        // primarySources是SpringApplication.run的参数，存放的是主配置类
        this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
        
        // 进行Web应用的类型推断
        this.webApplicationType = WebApplicationType.deduceFromClasspath();
        
        // 加载应用上下文初始化器 initializer
        setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
        
        // 加载应用事件监听器 listener
        setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
        
        // 推断引导类，也就是找到入口类
        this.mainApplicationClass = deduceMainApplicationClass();
    }
    
    ...
    
}

接下来，对构造器中的重点部分进行详细说明。

2.1、推断 Web 应用类型

SpringApplication允许指定应用的类型，大体上包括Web应用和非Web应用。从 Spring Boot 2.0开始，Web应用又可分为Servlet Web和Reactive Web。而在准备阶段，是通过检查当前ClassPath下某些Class是否存在，从而推导应用的类型。我们进入 WebApplicationType.deduceFromClasspath() 方法查看：

public enum WebApplicationType {

    /**
     * 非 web 项目
     */
    NONE,

    /**
     * servlet web 项目
     */
    SERVLET,
    
    /**
     * reactive web 项目
     */
    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";

    private static final String SERVLET_APPLICATION_CONTEXT_CLASS = "org.springframework.web.context.WebApplicationContext";

    private static final String REACTIVE_APPLICATION_CONTEXT_CLASS = "org.springframework.boot.web.reactive.context.ReactiveWebApplicationContext";

    static WebApplicationType deduceFromClasspath() {
        if (ClassUtils.isPresent(WEBFLUX_INDICATOR_CLASS, null) && !ClassUtils.isPresent(WEBMVC_INDICATOR_CLASS, null)
                && !ClassUtils.isPresent(JERSEY_INDICATOR_CLASS, null)) {
            return WebApplicationType.REACTIVE;
        }
        for (String className : SERVLET_INDICATOR_CLASSES) {
            if (!ClassUtils.isPresent(className, null)) {
                return WebApplicationType.NONE;
            }
        }
        return WebApplicationType.SERVLET;
    }

    ...

}

可以看到，在方法中利用 ClassUtils.isPresent 进行判断， 当DispatcherHandler存在，而DispatcherServlet和ServletContainer不存在时，则当前应用推导为 Reactive web 类型；当 Servlet 和 ConfigurableWebApplicationContext 不存在时，当前应用为非 Web 类型；其他的则为 Servlet Web 类型。

Reactive：Reactive响应式编程是一种新的编程风格，其特点是异步或并发、事件驱动、推送PUSH机制以及观察者模式的衍生。

2.2、加载应用上下文初始器 ApplicationContextInitializer

接着进入加载Spring应用上下文初始器的过程 setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class))：

public class SpringApplication {

    ...
    
    private List<ApplicationContextInitializer<?>> initializers;
    
    public void setInitializers(Collection<? extends ApplicationContextInitializer<?>> initializers) {
        this.initializers = new ArrayList<>();
        this.initializers.addAll(initializers);
    }
    
    private <T> Collection<T> getSpringFactoriesInstances(Class<T> type) {
        return getSpringFactoriesInstances(type, new Class<?>[] {});
    }
    
    private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
        ClassLoader classLoader = getClassLoader();
        // Use names and ensure unique to protect against duplicates
        Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
        List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
        AnnotationAwareOrderComparator.sort(instances);
        return instances;
    }
}

可以看到，这里是通过 Spring 工厂加载机制 SpringFactoriesLoader.loadFactoryNames(type, classLoader) 方法获取。结合上篇文章所讲，我们知道，该方法是从所有的 META-INF/spring.factories 资源中获取key为 ApplicationContextInitializer 的实现类集合，如下是 spring-boot-autoconfigure 包下的 spring.factories 文件：

# Initializers
org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,\
org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener

这里获取的就是 SharedMetadataReaderFactoryContextInitializer 和 ConditionEvaluationReportLoggingListener 上下文初始化器，接下来通过 createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names) 方法初始化这些实现类：

private <T> List<T> createSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes,
            ClassLoader classLoader, Object[] args, Set<String> names) {
    List<T> instances = new ArrayList<>(names.size());
    for (String name : names) {
        try {
            Class<?> instanceClass = ClassUtils.forName(name, classLoader);
            Assert.isAssignable(type, instanceClass);
            Constructor<?> constructor = instanceClass.getDeclaredConstructor(parameterTypes);
            T instance = (T) BeanUtils.instantiateClass(constructor, args);
            instances.add(instance);
        }
        catch (Throwable ex) {
            throw new IllegalArgumentException("Cannot instantiate " + type + " : " + name, ex);
        }
    }
    return instances;
}

这里先通过 BeanUtils.instantiate 初始化这些类，然后将初始化的类保存至List进行返回，并进行排序操作，最后添加到SpringApplication的initializers集合变量中。至此，该流程结束。

我们举例来看看初始器中的内容，如SharedMetadataReaderFactoryContextInitializer：

class SharedMetadataReaderFactoryContextInitializer
        implements ApplicationContextInitializer<ConfigurableApplicationContext>, Ordered {

    ...
    
    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        applicationContext.addBeanFactoryPostProcessor(new CachingMetadataReaderFactoryPostProcessor());
    }

    ...

}

可以看到该类实现了 Spring 的 ApplicationContextInitializer 接口，并重写了initialize()方法。同理，其他的 Initializer 接口也是类似实现。 而在这里则是在上下文中加入了 CachingMetadataReaderFactoryPostProcessor bean工厂后置处理器。

ApplicationContextInitializer 接口的主要作用是在 ConfigurableApplicationContext#refresh() 方法调用之前做一些初始化工作。

2.3、加载应用事件监听器 ApplicationListener

接着加载应用事件监听器 setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class))，过程与“加载应用上下文初始器”基本一致，同样是调用 getSpringFactoriesInstances 方法，不过这里获取的是 key 为 ApplicationListener 的对象集合，如下是 spring-boot-autoconfigure 包下的 spring.factories 文件：：

# Application Listeners
org.springframework.context.ApplicationListener=\
org.springframework.boot.autoconfigure.BackgroundPreinitializer

最后，将获取的 BackgroundPreinitializer 对象通过 setListeners 方法放入 listeners 属性变量中：

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

我们同样举例，来看看监听器中的内容，如BackgroundPreinitializer：

public class BackgroundPreinitializer implements ApplicationListener<SpringApplicationEvent> {

    ...
    
    @Override
    public void onApplicationEvent(SpringApplicationEvent event) {
        if (!Boolean.getBoolean(IGNORE_BACKGROUNDPREINITIALIZER_PROPERTY_NAME)
                && event instanceof ApplicationStartingEvent && preinitializationStarted.compareAndSet(false, true)) {
            
            ...
            
        }
        if ((event instanceof ApplicationReadyEvent || event instanceof ApplicationFailedEvent)
                && preinitializationStarted.get()) {
                
            ...
            
        }
    }
    
    ...
}

可以看到，该类实现了 Spring 的 ApplicationListener 接口，在重写的 onApplicationEvent 方法中触发相应的事件进行操作。同理，其他 Listener 也是类似实现。而该接口的主要功能是另起一个后台线程触发那些耗时的初始化，包括验证器、消息转换器等等。

目前spring boot中支持的事件类型如下：

• ApplicationFailedEvent：该事件为spring boot启动失败时的操作
• ApplicationPreparedEvent：上下文context准备时触发
• ApplicationReadyEvent：上下文已经准备完毕的时候触发
• ApplicationStartedEvent：spring boot 启动监听类
• SpringApplicationEvent：获取SpringApplication
• ApplicationEnvironmentPreparedEvent：环境事先准备

2.4、推断应用引导类

准备阶段的最后一步是推断应用的引导类，也就是获取启动 main 方法的类，执行的是 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;
}

可以看到，通过 getStackTrace()方法获取当前线程的执行栈，再通过 getMethodName()获取方法名，判断是否是 main 方法，最后返回 main 方法的所在类。

3、SpringApplication 配置

        SpringApplication 准备阶段结束后，按道理应该进入运行阶段，但运行阶段之前还有一个操作，就是可以修改 SpringApplication 默认配置。开头的代码示例可以看到，应用程序主类中的main方法中写的都是SpringApplication.run(xx.class)，可能这种写法不满足我们的需求，我们可以对SpringApplication进行一些配置，例如关闭Banner，设置一些默认的属性等。下面则是利用 SpringApplicationBuilder 的方式来添加配置：

@SpringBootApplication
public class DiveInSpringBootApplication {
    public static void main(String[] args) {
        new SpringApplicationBuilder(DiveInSpringBootApplication.class)
                
                // 设置当前应用类型
                .web(WebApplicationType.SERVLET)
                
                // 设置 banner 横幅打印方式、有关闭、日志、控制台
                .bannerMode(Banner.Mode.OFF)
                
                // 设置自定义的 banner
                .banner()
                
                // 追加自定义的 initializer 到集合中 
                .initializers()
                
                // 追加自定义的 listeners 到集合中
                .listeners()
                .run(args);
    }
}

可以看到，使用该方式实现的SpringApplication可以对其添加自定义的配置。当然配置远远不止这么点，其它的还请自行观看源码。

4、总结

        至此，SpringApplication 的准备工作结束，其实主要是对primarySources、webApplicationType、initializers、listeners、mainApplicationClass 这几个属性进行初始化，以及对 SpringApplication 进行自定义配置 。下篇文章，就来讲讲SpringApplication运行阶段，在运行阶段中这些 SpringApplication的配置和应用初始化器、监听器等如何被使用。

以上就是本章的内容，如过文章中有错误或者需要补充的请及时提出，本人感激不尽。



参考：

《Spring Boot 编程思想》