SpringBoot啟動流程分析原理（一）

2021 年 3 月 7 日
筆記
Spring Boot

我們都知道SpringBoot自問世以來，一直有一個響亮的口號”約定優於配置”，其實一種按約定編程的軟件設計範式，目的在於減少軟件開發人員在工作中的各種繁瑣的配置，我們都知道傳統的SSM框架的組合，會伴隨着大量的繁瑣的配置；稍有不慎，就可能各種bug，被人發現還以為我們技術很菜。而SpringBoot的出現不僅大大提高的開發人員的效率，還能避免由於”手抖”帶來的配置錯誤。

很多程序員都感慨SpringBoot的到來大大解放了生產力，但是也有聰明的程序猿會多思考一下下，SpringBoot是怎麼做到的約定的配置?它配置在了哪裡?又是怎麼啟動的作用等等一系列的問號在跟女朋友花前月下的時候，依然會時不時冒出來。這嚴重影響了程序猿們的”幸”福生活，為了能廣大”程序猿”同胞過上幸福美滿的生活，今天咱么就來一起跟隨源碼探究下SpringBoot到底是如何做到”約定優於配置“的。

首先，我們先介紹下我們的演示的項目環境，我們先試用 Spring Initializr來創建一個SpirngBoot 工程。我們使用的版本是SpringBoot 2.4.3.RELEASE

接下來就只在 pom.xmL文件中添加一個web工程的依賴，是為了觀察後面容器類型的源碼。

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

這樣我們的環境就準備好了。
我們跟着 SpringBoot的源碼來探究它的啟動流程，首先，先找到這個應用程序的入口主方法，在上面打一個斷點:

啟動之後，F7進入到 run（）方法，我的電腦是點擊F7(Step into)

到這裡會執行 new SpringApplication(primarySources)創建spring應用對象，繼續F7往下跟會執行 SpringApplication構造器

    //SpringApplication構造器
    public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
        // 此處省略源碼...

        // 資源加載器
        this.resourceLoader = resourceLoader;
        Assert.notNull(primarySources, "PrimarySources must not be null");
        this.primarySources = new LinkedHashSet(Arrays.asList(primarySources));
        // 1.可能的web應用程序類型的類型。
        this.webApplicationType = WebApplicationType.deduceFromClasspath();
        this.bootstrappers = new ArrayList(this.getSpringFactoriesInstances(Bootstrapper.class));
        // 2.設置初始化應用context
        this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));
        // 3.設置初始化監聽
        this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
        // 4.推演主程序類
        this.mainApplicationClass = this.deduceMainApplicationClass();
    }

很多不為人知的事情都是發生在這個對象初始化的時候，這裡我們都來一一解密

    static WebApplicationType deduceFromClasspath() {
        if (ClassUtils.isPresent("org.springframework.web.reactive.DispatcherHandler", (ClassLoader)null) && !ClassUtils.isPresent("org.springframework.web.servlet.DispatcherServlet", (ClassLoader)null) && !ClassUtils.isPresent("org.glassfish.jersey.servlet.ServletContainer", (ClassLoader)null)) {
            return REACTIVE;
        } else {
            String[] var0 = SERVLET_INDICATOR_CLASSES;
            int var1 = var0.length;

            for(int var2 = 0; var2 < var1; ++var2) {
                String className = var0[var2];
                if (!ClassUtils.isPresent(className, (ClassLoader)null)) {
                    return NONE;
                }
            }
            // 這裡是我們測試web容器
            return SERVLET;
        }
    }

1. 推斷web 應用類型

這段代碼是來推斷我們的應用是哪種web應用程序

public enum WebApplicationType{
  
    NONE，// 不是web應用
  
    SERVLET，// servlet容器
   
    REACTIVE; // 反應型web應用（webflux）
}

當然一開始我們加入了web的依賴，所以我們是 servlet 容器。

2. 初始化應用上下文

在設置初始化應用context的時候，是先執行了getSpringFactoriesInstances（ApplicationContextInitializer.class）方法，參數是ApplicationContextInitializer.class位元組碼對象。

    private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
        ClassLoader classLoader = this.getClassLoader();
        // Use names and ensure unique to protect against dupLicates
        Set<String> names = new LinkedHashSet(
                 // 加載ApplicationContextInitializer.class類型的類
                 // 這裡傳入就是參數 ApplicationContextInitializer.class
                SpringFactoriesLoader.loadFactoryNames(type, classLoader));
        // 實例化加載到的類
        List<T> instances = this.createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
        AnnotationAwareOrderComparator.sort(instances);
        // 返回
        return instances;
    }

我們先來看看他是如何加載到這些類

    private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
        // 從緩存中拿
        Map<String, List<String>> result = (Map)cache.get(classLoader);
        if (result != null) {
            return result;
        } else {
            HashMap result = new HashMap();

            try {
                // 從資源路徑下加載
                Enumeration urls = classLoader.getResources("META-INF/spring.factories");

                while(urls.hasMoreElements()) {
                    URL url = (URL)urls.nextElement();
                    UrlResource resource = new UrlResource(url);
                    Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                    Iterator var6 = properties.entrySet().iterator();

                    while(var6.hasNext()) {
                        Entry<?, ?> entry = (Entry)var6.next();
                        String factoryTypeName = ((String)entry.getKey()).trim();
                        String[] factoryImplementationNames = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                        String[] var10 = factoryImplementationNames;
                        int var11 = factoryImplementationNames.length;

                        for(int var12 = 0; var12 < var11; ++var12) {
                            String factoryImplementationName = var10[var12];
                            ((List)result.computeIfAbsent(factoryTypeName, (key) -> {
                                return new ArrayList();
                            })).add(factoryImplementationName.trim());
                        }
                    }
                }

                result.replaceAll((factoryType, implementations) -> {
                    return (List)implementations.stream().distinct().collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList));
                });
                cache.put(classLoader, result);
                // 返回所有的加載的類
                return result;
            } catch (IOException var14) {
                throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var14);
            }
        }
    }

這裡有兩個加載配置類的地方其實都指向了META-INF/spring.factories，通過斷點我們可以看到應用程序是加載了以下幾個jar下的 spring.factories 文件。

雙擊Shifi搜索spring.factories可以看到它存在於以下工程中

spring-boot-2.4.3.RELEASE.jar 下的 spring.factories （截圖未完整截取）

spring-boot-autoconfigure-2.4.3.RELEASE.jar 下的 spring.factories

spring-beans-2.4.3.RELEASE.jar 下的 spring.factories

從Map中根據 org.springframework.context.ApplicationContextInitializer 的類型拿到需要的類初始化類，斷點進入 getOrDefault（factoryClassName，Collections.emptyList（））;方法

之後就是把加載到的需要初始化的類進行實例化添加到一個集合中等待備用

3. 初始化監聽器類

最關鍵的的還是這句

當我們跟進去之後，會發現在初始化監聽類的時候和上面初始化應用上下文是一樣的代碼。唯一不同的是 getSpringFactoriesInstances（ApplicationListener.class））傳進去的是·ApplicationListener.class 所以這裡就不再贅述。

4. 推演主程序類

也就是這個最關鍵的代碼了
this.mainApplicationClass = this.deduceMainApplicationClass();

到這裡就完成了SpringBoot啟動過程中初始化SpringApplication 的過程。

這篇文章主要是給大家說了下SpringBoot 啟動過程中初始化SpringApplication的流程，大致可以分為四個步驟∶

推演web應用的類型（如果沒有加web依賴類型NONE）
初始化 ApplicationContextInitializer
初始化 ApplicationListener
推演出主程序類
通過這樣四個步驟就完成了第一步 SpringApplication 的初始化過程。

Tags: Spring Boot