Springboot啟動原理-有解無憂

Springboot啟動原理

    public static void main(String[] args) {
        //xxx.class：主配置類，（可以傳多個）
        SpringApplication.run(xxx.class, args);
    }

1. 從run方法開始，創建SpringApplication，然后再呼叫run方法

/**
 * ConfigurableApplicationContext(可配置的應用程式背景關系)
 */
public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
    //呼叫下面的run方法
    return run(new Class[]{primarySource}, args);
}

public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
    //primarySources：主配置類
    return (new SpringApplication(primarySources)).run(args);
}

2. 創建SpringApplication

public SpringApplication(Class<?>... primarySources) {
    //呼叫下面構造方法
    this((ResourceLoader) null, primarySources);
}

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
   //獲取類加載器
   this.resourceLoader = resourceLoader;
   //查看類加載器是否為空
   Assert.notNull(primarySources, "PrimarySources must not be null");
   // 保存主配置類的資訊到一個哈希鏈表集合中，方便查詢呼叫增刪
   this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
   //獲取當前應用的型別，是不是web應用，見2.1
   this.webApplicationType = WebApplicationType.deduceFromClasspath();
   //從類路徑下找到META‐INF/spring.factories配置的所有ApplicationContextInitializer；然后保存起來，見2.2
   setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
   //從類路徑下找到META‐INF/spring.factories配置的所有spring.ApplicationListener；然后保存起來,原理同上
   setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
   //從多個SpringApplication中找到有main方法的主SpringApplication(在調run方法的時候是可以傳遞多個配置類的)
   //只記錄有main方法的類名，以便下一步的run
   this.mainApplicationClass = deduceMainApplicationClass();
}

2.1 deduceFromClasspath

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;
}

2.2 getSpringFactoriesInstances

private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
   ClassLoader classLoader = getClassLoader();
   // Use names and ensure unique to protect against duplicates
   // 配置的所有ApplicationContextInitializer等分別到一個集合中以便查詢使用，其中loadFactoryNames方法從類路徑下找到META‐INF/spring.factories中傳入的parameterTypes
   Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
   // 實體化傳入的類
   List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
   // 排序以便提高針對他執行操作的效率
   AnnotationAwareOrderComparator.sort(instances);
   return instances;
}

2.3 deduceMainApplicationClass

private Class<?> deduceMainApplicationClass() {
   try {
       // 查詢當前的虛擬機的當前執行緒的StackTrace資訊
      StackTraceElement[] stackTrace = new RuntimeException().getStackTrace();
      for (StackTraceElement stackTraceElement : stackTrace) {
          // 查看當前執行緒中已加載的類中有沒有main方法
         if ("main".equals(stackTraceElement.getMethodName())) {
           //有則回傳該類的類名
            return Class.forName(stackTraceElement.getClassName());
         }
      }
   }
   catch (ClassNotFoundException ex) {
      // Swallow and continue
   }
   return null;
}

StackTrace簡述

1 StackTrace用堆疊的形式保存了方法的呼叫資訊.

2 怎么獲取這些呼叫資訊呢?

可用Thread.currentThread().getStackTrace()方法得到當前執行緒的StackTrace資訊.該方法回傳的是一個StackTraceElement陣列.

3 該StackTraceElement陣列就是StackTrace中的內容.

4 遍歷該StackTraceElement陣列.就可以看到方法間的呼叫流程.

比如執行緒中methodA呼叫了methodB那么methodA先入堆疊methodB再入堆疊.

5 在StackTraceElement陣列下標為2的元素中保存了當前方法的所屬檔案名,當前方法所屬的類名,以及該方法的名字

? 除此以外還可以獲取方法呼叫的行數.

6 在StackTraceElement陣列下標為3的元素中保存了當前方法的呼叫者的資訊和它呼叫時的代碼行數.

3. 呼叫SpringApplication物件的run方法

Apllication總體流程

SpringApplication的run方法的實作是我們本次旅程的主要線路，該方法的主要流程大體可以歸納如下：

1）如果我們使用的是SpringApplication的靜態run方法，那么，這個方法里面首先要創建一個SpringApplication物件實體，然后呼叫這個創建好的SpringApplication的實體方法，在SpringApplication實體初始化的時候，它會提前做幾件事情：

根據classpath里面是否存在某個特征類（org.springframework.web.context.ConfigurableWebApplicationContext）來決定是否應該創建一個為Web應用使用的ApplicationContext型別，

使用SpringFactoriesLoader在應用的classpath中查找并加載所有可用的ApplicationContextInitializer，

使用SpringFactoriesLoader在應用的classpath中查找并加載所有可用的ApplicationListener，

推斷并設定main方法的定義類，

2） SpringApplication實體初始化完成并且完成設定后，就開始執行run方法的邏輯了，方法執行伊始，首先遍歷執行所有通過SpringFactoriesLoader可以查找到并加載的SpringApplicationRunListener，呼叫它們的started()方法，告訴這些SpringApplicationRunListener，“嘿，SpringBoot應用要開始執行咯！”，

3）創建并配置當前Spring Boot應用將要使用的Environment（包括配置要使用的PropertySource以及Profile），

4）遍歷呼叫所有SpringApplicationRunListener的environmentPrepared()的方法，告訴他們：“當前SpringBoot應用使用的Environment準備好了咯！”，

5）如果SpringApplication的showBanner屬性被設定為true，則列印banner，

6）根據用戶是否明確設定了applicationContextClass型別以及初始化階段的推斷結果，決定該為當前SpringBoot應用創建什么型別的ApplicationContext并創建完成，然后根據條件決定是否添加ShutdownHook，決定是否使用自定義的BeanNameGenerator，決定是否使用自定義的ResourceLoader，當然，最重要的，將之前準備好的Environment設定給創建好的ApplicationContext使用，

7） ApplicationContext創建好之后，SpringApplication會再次借助Spring-FactoriesLoader，查找并加載classpath中所有可用的ApplicationContext-Initializer，然后遍歷呼叫這些ApplicationContextInitializer的initialize（applicationContext）方法來對已經創建好的ApplicationContext進行進一步的處理，

8）會呼叫SpringApplication的prepareContext方法，其中會遍歷呼叫所有SpringApplicationRunListener的contextPrepared()方法，

9）將之前通過@EnableAutoConfiguration獲取的所有配置以及其他形式的IoC容器配置加載到已經準備完畢的ApplicationContext，

10）遍歷呼叫所有SpringApplicationRunListener的contextLoaded()方法，

11）接著便是SpringApplication的afterRefresh方法，呼叫ApplicationContext的refresh()方法，完成IoC容器可用的最后一道工序，

12）查找當前ApplicationContext中是否注冊有CommandLineRunner，如果有，則遍歷執行它們，

13）正常情況下，遍歷執行SpringApplicationRunListener的finished()方法、（如果整個程序出現例外，則依然呼叫所有SpringApplicationRunListener的finished()方法，只不過這種情況下會將例外資訊一并傳入處理）

    public ConfigurableApplicationContext run(String... args) {
        //Simple stop watch, allowing for timing of a number of tasks, exposing totalrunning time and running time for each named task.簡單來說是創建ioc容器的計時器
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        //宣告IOC容器
        ConfigurableApplicationContext context = null;
        //例外報告存盤串列
        Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList();
        //加載圖形化配置
        this.configureHeadlessProperty();
        //從類路徑下META‐INF/spring.factories獲取SpringApplicationRunListeners，原理同2中獲取ApplicationContextInitializer和ApplicationListener
        SpringApplicationRunListeners listeners = this.getRunListeners(args);
        //遍歷上一步獲取的所有SpringApplicationRunListener，呼叫其starting方法
        listeners.starting();

        Collection exceptionReporters;
        try {
            //封裝命令列
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
            //準備環境，把上面獲取到的SpringApplicationRunListeners傳過去，見3.1
            ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments);
            
            this.configureIgnoreBeanInfo(environment);
            //列印Banner，就是控制臺那個Spring字符畫
            Banner printedBanner = this.printBanner(environment);
            //根據當前環境利用反射創建IOC容器，見3.2
            context = this.createApplicationContext();
        //從類路徑下META‐INF/spring.factories獲取SpringBootExceptionReporter，原理同2中獲取ApplicationContextInitializer和ApplicationListener
            exceptionReporters = this.getSpringFactoriesInstances(SpringBootExceptionReporter.class, new Class[]{ConfigurableApplicationContext.class}, context);
            //準備IOC容器，見3.3
            this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);
            //重繪IOC容器，可查看配置嵌入式Servlet容器原理，所有的@Configuration和@AutoConfigutation等Bean物件全在此時加入容器中，并依據不同的選項創建了不同功能如服務器/資料庫等組件，見3.4
            //可以說@SpringbootApplication中自動掃描包和Autoconfiguration也是在此時進行的
            this.refreshContext(context);
            //這是一個空方法
            this.afterRefresh(context, applicationArguments);
            //停止計時，列印時間
            stopWatch.stop();
            if (this.logStartupInfo) {
                (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch);
            }
            //呼叫所有SpringApplicationRunListener的started方法
            listeners.started(context);
            //見3.5 ，從ioc容器中獲取所有的ApplicationRunner和CommandLineRunner進行回呼ApplicationRunner先回呼，CommandLineRunner再回呼，
            this.callRunners(context, applicationArguments);
        } catch (Throwable var10) {
            this.handleRunFailure(context, var10, exceptionReporters, listeners);
            throw new IllegalStateException(var10);
        }

        try {
            //呼叫所有SpringApplicationRunListener的running方法
            listeners.running(context);
            //回傳創建好的ioc容器，啟動完成
            return context;
        } catch (Throwable var9) {
            this.handleRunFailure(context, var9, exceptionReporters, (SpringApplicationRunListeners)null);
            throw new IllegalStateException(var9);
        }
    }

3.1 prepareEnvironment

    private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments) {
        //獲取或者創建環境，有則獲取，無則創建
        ConfigurableEnvironment environment = this.getOrCreateEnvironment();
        //配置環境
        this.configureEnvironment((ConfigurableEnvironment)environment, applicationArguments.getSourceArgs());
        ConfigurationPropertySources.attach((Environment)environment);
        //創建環境完成后，ApplicationContext創建前，呼叫前面獲取的所有SpringApplicationRunListener的environmentPrepared方法，讀取組態檔使之生效
        listeners.environmentPrepared((ConfigurableEnvironment)environment);
        // 環境搭建好后，需依據他改變Apllication的引數，將enviroment的資訊放置到Binder中，再由Binder依據不同的條件將“spring.main”SpringApplication更改為不同的環境，為后面context的創建搭建環境
        //為什么boot要這樣做，其實咱們啟動一個boot的時候并不是一定只有一個Application且用main方式啟動，這樣子我們可以讀取souces配置多的Application
        this.bindToSpringApplication((ConfigurableEnvironment)environment);
        if (!this.isCustomEnvironment) {
            environment = (new EnvironmentConverter(this.getClassLoader())).convertEnvironmentIfNecessary((ConfigurableEnvironment)environment, this.deduceEnvironmentClass());
        }

        ConfigurationPropertySources.attach((Environment)environment);        
        //回到3，將創建好的environment回傳
        return (ConfigurableEnvironment)environment;
    }

3.2 createApplicationContext

    protected ConfigurableApplicationContext createApplicationContext() {        
        //獲取當前Application中ioc容器類
        Class<?> contextClass = this.applicationContextClass;
        //若沒有則依據該應用是否為web應用而創建相應的ioc容器
        //除非為其傳入applicationContext，不然Application的默認構造方法并不會創建ioc容器
        if (contextClass == null) {
            try {
                switch(this.webApplicationType) {
                case SERVLET:
                    contextClass = Class.forName("org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext");
                    break;
                case REACTIVE:
                    contextClass = Class.forName("org.springframework.boot.web.reactive.context.AnnotationConfigReactiveWebServerApplicationContext");
                    break;
                default:
                    contextClass = Class.forName("org.springframework.context.annotation.AnnotationConfigApplicationContext");
                }
            } catch (ClassNotFoundException var3) {
                throw new IllegalStateException("Unable create a default ApplicationContext, please specify an ApplicationContextClass", var3);
            }
        }
		//用bean工具類實體化ioc容器物件并回傳，回到3
        return (ConfigurableApplicationContext)BeanUtils.instantiateClass(contextClass);
    }

3.3 prepareContext

    private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment, SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {
        //將創建好的環境放到IOC容器中
        context.setEnvironment(environment);
        //處理一些組件，沒有實作postProcessA介面
        this.postProcessApplicationContext(context);
        //獲取所有的ApplicationContextInitializer呼叫其initialize方法，這些ApplicationContextInitializer就是在2步驟中獲取的，見3.3.1
        this.applyInitializers(context);
        //回呼所有的SpringApplicationRunListener的contextPrepared方法，這些SpringApplicationRunListeners是在步驟3中獲取的
        listeners.contextPrepared(context);

        //列印日志
        if (this.logStartupInfo) {
            this.logStartupInfo(context.getParent() == null);
            this.logStartupProfileInfo(context);
        }

        ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
        //將一些applicationArguments注冊成容器工廠中的單例物件
        beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
        if (printedBanner != null) {
            beanFactory.registerSingleton("springBootBanner", printedBanner);
        }

        if (beanFactory instanceof DefaultListableBeanFactory) {
            ((DefaultListableBeanFactory)beanFactory).setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
        }
		
        //若是延遲加載，則在ioc容器中加入LazyInitializationBeanFactoryPostProcessor，
        if (this.lazyInitialization) {
            context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
        }

        //獲取所有報告primarySources在內的所有source
        Set<Object> sources = this.getAllSources();
        Assert.notEmpty(sources, "Sources must not be empty");
        //加載容器
        this.load(context, sources.toArray(new Object[0]));
        //回呼所有的SpringApplicationRunListener的contextLoaded方法
        listeners.contextLoaded(context);
    }

3.3.1 applyInitializers

    protected void applyInitializers(ConfigurableApplicationContext context) {
        Iterator var2 = this.getInitializers().iterator();

        while(var2.hasNext()) {
            //將之前的所有的ApplicationContextInitializer遍歷
            ApplicationContextInitializer initializer = (ApplicationContextInitializer)var2.next();
            //決議查看之前從spring.factories呼叫的ApplicationContextInitializer是否能被ioc容器呼叫
            Class<?> requiredType = GenericTypeResolver.resolveTypeArgument(initializer.getClass(), ApplicationContextInitializer.class);
            Assert.isInstanceOf(requiredType, context, "Unable to call initializer.");
            //可以呼叫則對ioc容器進行初始化（還沒加載我們自己配置的bean和AutoConfiguration那些）
            initializer.initialize(context);
        }

    }//回傳3.3

3.4 refreshment(context)

@Override 
//詳情見內置Servlet的啟動原理,最后是用ApplicationContext的實作類的refresh()方法，若是web Application則為ServletWebServerApplicationContext
public void refresh() throws BeansException, IllegalStateException {
   synchronized (this.startupShutdownMonitor) {
      // Prepare this context for refreshing.
      prepareRefresh();

      // Tell the subclass to refresh the internal bean factory.
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

      // Prepare the bean factory for use in this context.
      prepareBeanFactory(beanFactory);

      try {
         // Allows post-processing of the bean factory in context subclasses.
         postProcessBeanFactory(beanFactory);

         // Invoke factory processors registered as beans in the context.
         invokeBeanFactoryPostProcessors(beanFactory);

         // Register bean processors that intercept bean creation.
         registerBeanPostProcessors(beanFactory);

         // Initialize message source for this context.
         initMessageSource();

         // Initialize event multicaster for this context.
         initApplicationEventMulticaster();

         // Initialize other special beans in specific context subclasses.
         onRefresh();

         // Check for listener beans and register them.
         registerListeners();

         // Instantiate all remaining (non-lazy-init) singletons.
         finishBeanFactoryInitialization(beanFactory);

         // Last step: publish corresponding event.
         finishRefresh();
      }

      catch (BeansException ex) {
         if (logger.isWarnEnabled()) {
            logger.warn("Exception encountered during context initialization - " +
                  "cancelling refresh attempt: " + ex);
         }

         // Destroy already created singletons to avoid dangling resources.
         destroyBeans();

         // Reset 'active' flag.
         cancelRefresh(ex);

         // Propagate exception to caller.
         throw ex;
      }

      finally {
         // Reset common introspection caches in Spring's core, since we
         // might not ever need metadata for singleton beans anymore...
         resetCommonCaches();
      }
   }
}

3.5 callRunners

    private void callRunners(ApplicationContext context, ApplicationArguments args) {
        List<Object> runners = new ArrayList();
        //將ioc容器中的的ApplicationRunner和CommandLineRunner（），在創建ioc容器時創建的
        runners.addAll(context.getBeansOfType(ApplicationRunner.class).values());
        runners.addAll(context.getBeansOfType(CommandLineRunner.class).values());
        AnnotationAwareOrderComparator.sort(runners);
        Iterator var4 = (new LinkedHashSet(runners)).iterator();
		
        //呼叫ApplicationRunner和CommandLineRunner的run方法
        while(var4.hasNext()) {
            Object runner = var4.next();
            if (runner instanceof ApplicationRunner) {
                this.callRunner((ApplicationRunner)runner, args);
            }

            if (runner instanceof CommandLineRunner) {
                this.callRunner((CommandLineRunner)runner, args);
            }
        }

    }

配置在META-INF/spring.factories

ApplicationContextInitializer（在我們將enviroment系結到application后可以用來創建不同型別的context）
SpringApplicationRunListener（在Application 創建/運行/銷毀等進行一些我們想要的特殊配置）

只需要放在ioc容器中

ApplicationRunner（加載沒有在ApplicationContext中的bean時讓bean能加載）
CommandLineRunner（命令列執行器）

Application初始化組件測驗

創建ApplicationContextInitializer和SpringApplicationRunListener的實作類，并在META-INF/spring.factories檔案中配置

public class TestApplicationContextInitializer implements ApplicationContextInitializer {

    @Override
    public void initialize(ConfigurableApplicationContext configurableApplicationContext) {
        System.out.println("TestApplicationContextInitializer.initialize");
    }
}

public class TestSpringApplicationRunListener implements SpringApplicationRunListener {
    @Override
    public void starting() {
        System.out.println("TestSpringApplicationRunListener.starting");
    }

    @Override
    public void environmentPrepared(ConfigurableEnvironment environment) {
        System.out.println("TestSpringApplicationRunListener.environmentPrepared");
    }

    @Override
    public void contextPrepared(ConfigurableApplicationContext context) {
        System.out.println("TestSpringApplicationRunListener.contextPrepared");
    }

    @Override
    public void contextLoaded(ConfigurableApplicationContext context) {
        System.out.println("TestSpringApplicationRunListener.contextLoaded");
    }

    @Override
    public void started(ConfigurableApplicationContext context) {
        System.out.println("TestSpringApplicationRunListener.started");
    }

    @Override
    public void running(ConfigurableApplicationContext context) {
        System.out.println("TestSpringApplicationRunListener.running");
    }

    @Override
    public void failed(ConfigurableApplicationContext context, Throwable exception) {
        System.out.println("TestSpringApplicationRunListener.failed");
    }
}

org.springframework.context.ApplicationContextInitializer=\
cn.clboy.springbootprocess.init.TestApplicationContextInitializer

org.springframework.boot.SpringApplicationRunListener=\
cn.clboy.springbootprocess.init.TestSpringApplicationRunListener

啟動報錯：說是沒有找到帶org.springframework.boot.SpringApplication和String陣列型別引數的構造器，給TestSpringApplicationRunListener添加這樣的構造器

    public TestSpringApplicationRunListener(SpringApplication application,String[] args) {
    }

創建ApplicationRunner實作類和CommandLineRunner實作類，因為是從ioc容器完成創建后中提取存放在里面的這兩個Runner，因此可以直接添加到容器中，最后callRunner使用

@Component
public class TestApplicationRunner implements ApplicationRunner {

    @Override
    public void run(ApplicationArguments args) throws Exception {
        System.out.println("TestApplicationRunner.run\t--->"+args);
    }
}

@Component
public class TestCommandLineRunn implements CommandLineRunner {

    @Override
    public void run(String... args) throws Exception {
        System.out.println("TestCommandLineRunn.runt\t--->"+ Arrays.toString(args));
    }
}

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/38616.html

標籤：Java

上一篇：mysql執行計劃，就這樣5000+字，被解釋的清清楚楚

下一篇：Java隨談（一）魔術數字、常量和列舉