@SpringBootApplication
@Slf4j
public class ApplicationMain {
    public static void main(String[] args) {
        ConfigurableApplicationContext ctx = SpringApplication.run(ApplicationMain.class, args);
    }
}

Create an appropriate ApplicationContext instance (depending on your classpath) Register a CommandLinePropertySource to expose command line arguments as Spring properties Refresh the application context, loading all singleton beans Trigger any CommandLineRunner beans

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

this.resourceLoader = resourceLoader;
Assert.notNull(primarySources, "PrimarySources must not be null");
this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
//通過Classloader探測不同web應用核心類是否存在，進而設置web應用類型
this.webApplicationType = WebApplicationType.deduceFromClasspath(); 
//找出所有spring.factories中聲明的ApplicationContextInitializer并設置，
//ApplicationContextInitializer定義了回調接口，在refresh()前初始化調用（即在prepareContext的applyInitializers方法中調用）
setInitializers((Collection) getSpringFactoriesInstances(
ApplicationContextInitializer.class));
//找出所有spring.factories中聲明的ApplicationListener（細節(jié)往后再敘），ApplicationListener繼承了
//java.util.EventListener，實現(xiàn)了類似觀察者模式的形式，通過實現(xiàn)ApplicationListener、SmartApplicationListener，能夠監(jiān)聽Spring上下文的refresh、Prepared等事件或者是自定義事件
setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
//找出主啟動類（有趣的是，是通過new一個runtime異常然后在異常棧里面找出來的）
this.mainApplicationClass = deduceMainApplicationClass();

//java.awt.headless，是J2SE的一種模式，用于在缺失顯示屏、鼠標或者鍵盤時的系統(tǒng)配置。
configureHeadlessProperty();
//將spring.factories中的SpringApplicationRunListener接口實現(xiàn)類拖出來，塞到SpringApplicationRunListeners（一個集合）中，統(tǒng)一批量執(zhí)行
SpringApplicationRunListeners listeners = getRunListeners(args);
//觸發(fā)runlistener的starting
listeners.starting();
try {
   ApplicationArguments applicationArguments = new DefaultApplicationArguments(
         args);
   ConfigurableEnvironment environment = prepareEnvironment(listeners,
         applicationArguments);
   //spring.beaninfo.ignore如果沒有設置值，則把它設為true，具體情況具體設置，
   //如果沒用的話，把它設為true可以ignore掉classloader對于不存在的BeanInfo的掃描，提高性能。
   configureIgnoreBeanInfo(environment);
   //banner打印。自定義banner挺好玩的
   Banner printedBanner = printBanner(environment);
   //根據(jù)webApplicationType（一開始推斷的應用類型）去新建applicationContext
   context = createApplicationContext();
   //獲取SpringBootExceptionReporter，回調接口類，提供啟動時的異常報告
   exceptionReporters = getSpringFactoriesInstances(
         SpringBootExceptionReporter.class,
         new Class[] { ConfigurableApplicationContext.class }, context);
   //下面會說
   prepareContext(context, environment, listeners, applicationArguments,
         printedBanner);
   refreshContext(context);
   //do nothing
   afterRefresh(context, applicationArguments);
   //計時停止
   stopWatch.stop();
   //打日志
   if (this.logStartupInfo) {
      new StartupInfoLogger(this.mainApplicationClass)
            .logStarted(getApplicationLog(), stopWatch);
   }
   //啟動
   listeners.started(context);
   //找出context的ApplicationRunner和CommandLineRunner，用AnnotationAwareOrderComparator排序，并執(zhí)行
   callRunners(context, applicationArguments);

private ConfigurableEnvironment prepareEnvironment(
      SpringApplicationRunListeners listeners,
      ApplicationArguments applicationArguments) {
   // Create and configure the environment
   ConfigurableEnvironment environment = getOrCreateEnvironment();
   configureEnvironment(environment, applicationArguments.getSourceArgs());
   //發(fā)布environment prepared事件
   listeners.environmentPrepared(environment);
   //將獲取到的environment中的spring.main配置綁定到SpringApplication中,
   //使用的是Binder這個spring boot2.0開始有的類
   bindToSpringApplication(environment);
   if (!this.isCustomEnvironment) {
      environment = new EnvironmentConverter(getClassLoader())
            .convertEnvironmentIfNecessary(environment, deduceEnvironmentClass());
   }
   //附加的解析器將動態(tài)跟蹤底層 Environment 屬性源的任何添加或刪除，
   //關于ConfigurationPropertySourcesPropertySource和MutablePropertiySource
   //將在Environment中作進一步講解
   ConfigurationPropertySources.attach(environment);
   return environment;
}

private void prepareContext(ConfigurableApplicationContext context,
      ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
      ApplicationArguments applicationArguments, Banner printedBanner) {
   //為上下文設置environment（配置、profile）
   context.setEnvironment(environment);
   //對application做一些處理，設置一些組件，
   //比如BeanNameGenerator，ApplicationConversionService（包含一些默認的Converter和formatter）
   postProcessApplicationContext(context);
   // 加載并運行ApplicationContextInitializer
   applyInitializers(context);
   listeners.contextPrepared(context);
   if (this.logStartupInfo) {
      logStartupInfo(context.getParent() == null);
      logStartupProfileInfo(context);
   }
   // Add boot specific singleton beans
   ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
   beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
   if (printedBanner != null) {
      beanFactory.registerSingleton("springBootBanner", printedBanner);
   }
   if (beanFactory instanceof DefaultListableBeanFactory) {
      ((DefaultListableBeanFactory) beanFactory)
            .setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
   }
   // Load the sources
   Set<Object> sources = getAllSources();
   Assert.notEmpty(sources, "Sources must not be empty");
   //Load beans（其實是由sources構建beanDefinition） into the application context. 
   //構建BeanDefinitionLoader并執(zhí)行BeanDefinitionLoader.load()
   load(context, sources.toArray(new Object[0]));
   //執(zhí)行contextLoaded事件
   listeners.contextLoaded(context);
}

private void refreshContext(ConfigurableApplicationContext context) {
    refresh(context);
    if (this.registerShutdownHook) {
        try {
            context.registerShutdownHook();
        }
        catch (AccessControlException ex) {
            // Not allowed in some environments.
        }
    }
}

// ServletWebServerApplicationContext 
public final void refresh() throws BeansException, IllegalStateException {
   try {
      super.refresh();
   }
   catch (RuntimeException ex) {
      //停止webserver
      stopAndReleaseWebServer();
      throw ex;
   }
}
org.springframework.context.support.AbstractApplicationContext refresh()
public void refresh() throws BeansException, IllegalStateException {
   // 單線程執(zhí)行
   synchronized (this.startupShutdownMonitor) {
      // Prepare this context for refreshing.
      // 1、設置Spring容器的啟動時間，撤銷關閉狀態(tài)，開啟活躍狀態(tài)。2、初始化屬性源信息(Property)3、驗證環(huán)境信息里一些必須存在的屬性
      prepareRefresh();
      // Tell the subclass to refresh the internal bean factory.
      // 如果是RefreshtableApplicationContext會做了很多事情：
      // 1、讓子類刷新內部beanFactory ，創(chuàng)建IoC容器（DefaultListableBeanFactory--ConfigurableListableBeanFactory 的實現(xiàn)類）
      // 2、加載解析XML文件（最終存儲到Document對象中）
      // 3、讀取Document對象，并完成BeanDefinition的加載和注冊工作
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
      // Prepare the bean factory for use in this context.
      //從Spring容器獲取BeanFactory(Spring Bean容器)并進行相關的設置為后續(xù)的使用做準備：
      //1、設置classloader(用于加載bean)，設置表達式解析器(解析bean定義中的一些表達式)，添加屬性編輯注冊器(注冊屬性編輯器)
      //2、添加ApplicationContextAwareProcessor這個BeanPostProcessor。取消ResourceLoaderAware、ApplicationEventPublisherAware、MessageSourceAware、ApplicationContextAware、EnvironmentAware這5個接口的自動注入。因為ApplicationContextAwareProcessor把這5個接口的實現(xiàn)工作做了
      //3、設置特殊的類型對應的bean。BeanFactory對應剛剛獲取的BeanFactory；ResourceLoader、ApplicationEventPublisher、ApplicationContext這3個接口對應的bean都設置為當前的Spring容器
      //4、注入一些其它信息的bean，比如environment、systemProperties等
      prepareBeanFactory(beanFactory);
      try {
         // Allows post-processing of the bean factory in context subclasses.
         postProcessBeanFactory(beanFactory);
         // Invoke factory processors registered as beans in the context. 執(zhí)行beanfactoryPostProcessor
         invokeBeanFactoryPostProcessors(beanFactory);
         // Register bean processors that intercept bean creation. 
         // 注冊beanPostProcessor
         registerBeanPostProcessors(beanFactory);
         // Initialize message source for this context. 初始化messageSource
         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();
      }
   }
}

protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    // 父類實現(xiàn)，會注冊web應用特有的factory scope， 
    super.postProcessBeanFactory(beanFactory);
    //查看basePackages屬性，如果設置了會使用ClassPathBeanDefinitionScanner去掃描basePackages包下的bean并注
    if (this.basePackages != null && this.basePackages.length > 0) {
        this.scanner.scan(this.basePackages);
    }
    // 查看annotatedClasses屬性，如果設置了會使用AnnotatedBeanDefinitionReader去注冊這些bean
    if (!this.annotatedClasses.isEmpty()) {
        this.reader.register(ClassUtils.toClassArray(this.annotatedClasses));
    }
}

/**
 * Instantiate and invoke all registered BeanFactoryPostProcessor beans,
 * respecting explicit order if given.
 * <p>Must be called before singleton instantiation.
 */
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    //執(zhí)行AbstractContext持有的BeanFactory后置處理器
    //這些處理器是之前ContextInitializer
    PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
    // Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
    // (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
    // 如果通過-javaagent參數(shù)設置了LTW的織入器類包，那么增加LTW的BeanProcessor。
    if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }
}

···java
/**
Instantiate and invoke all registered BeanPostProcessor beans,respecting explicit order if given.
Must be called before any instantiation of application beans.
*/
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
//委派PostProcessorRegistrationDelegate去做
PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}

從Spring容器中按一定順序（PriorityOrdered、Ordered、非PriorityOrdered非Ordered）找出實現(xiàn)了BeanPostProcessor接口的bean，并設置到BeanFactory的屬性中。之后bean被實例化的時候會調用這個BeanPostProcessor。
## 十、initMessageSource()
初始化一些國際化相關的屬性。
Spring boot的國際化配置可閱讀MessageSourceAutoConfiguration。 默認情況會設置一個DelegatingMessageSource，是一個空實現(xiàn)，因為ApplicationContext接口拓展了MessageSource接口，所以Spring容器都有getMessage方法， 可是，在實現(xiàn)上又允許空MessageSource，所以，通過一個DelegatingMessageSource去適配。
## 十一、initApplicationEventMulticaster()
Initialize event multicaster for this context. 初始化事件廣播器。默認實現(xiàn)是SimpleApplicationEventMulticaster。
onRefresh()
模板方法，給不同的Spring應用容器去實例化一些特殊的類。
比如，AnnotationConfigServletWebServerApplicationContext、AnnotationConfigReactiveWebServerApplicationContext會去創(chuàng)建web server（createWebServer()）。 spring boot的mvc內置支持有tomcat、Undertow、jetty三種server，而reactive web server則內置支持tomcat、jetty、netty三種。
java
// Unlike Jetty, all Tomcat threads are daemon threads. We create a
// blocking non-daemon to stop immediate shutdown
startDaemonAwaitThread();

// ReactiveWebServerApplicationContext
    @Override
    protected void finishRefresh() {
        super.finishRefresh();
        WebServer webServer = startReactiveWebServer();
        if (webServer != null) {
            publishEvent(new ReactiveWebServerInitializedEvent(webServer, this));
        }
    }
// AbstractApplicationContext
    /**
     * Finish the refresh of this context, invoking the LifecycleProcessor's
     * onRefresh() method and publishing the
     * {@link org.springframework.context.event.ContextRefreshedEvent}.
     */
    protected void finishRefresh() {
        // Clear context-level resource caches (such as ASM metadata from scanning).
        // 容器完成刷新，清除資源緩存
        clearResourceCaches();
        // Initialize lifecycle processor for this context.
        // 初始化lifeCycleProcessor, 默認實現(xiàn)是DefaultLifeCycleProcessor，實現(xiàn)了BeanFactoryAware接口，通過BeanFactory找出LifeCycle bean
        // 可通過自定義實現(xiàn)LifeCycle接口的Bean，來監(jiān)聽容器的生命周期。
        initLifecycleProcessor();
        // Propagate refresh to lifecycle processor first.
        //粗發(fā)生命周期處理器的onRefresh方法，順帶一說，在程序正常退出時，會粗發(fā)shutdownHook，那時會粗發(fā)生命周期處理器的onClose方法
        getLifecycleProcessor().onRefresh();
        // Publish the final event.
        // 廣播ContextRefreshed事件
        publishEvent(new ContextRefreshedEvent(this));
        // Participate in LiveBeansView MBean, if active.
        // 將ApplicationContext注冊到Spring tool suite里
        LiveBeansView.registerApplicationContext(this);
    }

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