Spring Boot SpringApplication启动类（一） - WebApplicationType、ApplicationContextInitializer、ApplicationLi

时间  2020-01-02
标签 spring boot springapplication 启动 webapplicationtype applicationcontextinitializer applicationli 栏目 Spring 繁體版
原文   原文链接

目录java

前言

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

开始以前呢，但愿你们带着几个问题去学习：
一、Spring Boot SpringApplication是什么？
二、怎么实现的？
三、优势和缺点是什么？
四、是怎么和 Spring 关联起来的？
这是对自个人提问，我认为带着问题去学习，是一种更好的学习方式，有利于加深理解。好了，接下来进入主题。web

一、起源

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

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

二、SpringApplication 准备阶段

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

先来看看启动类：app

@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 的构造器中处理：ide

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();
    }
    
    ...
    
}

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

2.一、推断 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.二、加载应用上下文初始器 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.三、加载应用事件监听器 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.四、推断应用引导类

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

三、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能够对其添加自定义的配置。固然配置远远不止这么点，其它的还请自行观看源码。

四、总结

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

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



参考：

《Spring Boot 编程思想》

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程