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教程