SpringApplication到底run了什麼（下）

在上篇文章中SpringApplication到底run了什麼（上）中，咱們分析了下面這個run方法的前半部分，本篇文章繼續開工

public ConfigurableApplicationContext run(String... args) {
            //。。。
            //接上文繼續
            configureIgnoreBeanInfo(environment);
            Banner printedBanner = printBanner(environment);
            context = createApplicationContext();
            exceptionReporters = getSpringFactoriesInstances(
                    SpringBootExceptionReporter.class,
                    new Class[] { ConfigurableApplicationContext.class }, context);
            prepareContext(context, environment, listeners, applicationArguments,
                    printedBanner);
            refreshContext(context);
            afterRefresh(context, applicationArguments);
            stopWatch.stop();
            if (this.logStartupInfo) {
                new StartupInfoLogger(this.mainApplicationClass)
                        .logStarted(getApplicationLog(), stopWatch);
            }
            listeners.started(context);
            callRunners(context, applicationArguments);
        }
        catch (Throwable ex) {
            handleRunFailure(context, listeners, exceptionReporters, ex);
            throw new IllegalStateException(ex);
        }
        listeners.running(context);
        return context;
    }

1. 獲取系統屬性spring.beaninfo.ignore

private void configureIgnoreBeanInfo(ConfigurableEnvironment environment) {
        if (System.getProperty(
                CachedIntrospectionResults."spring.beaninfo.ignore") == null) {
            Boolean ignore = environment.getProperty("spring.beaninfo.ignore",
                    Boolean.class, Boolean.TRUE);
            System.setProperty(CachedIntrospectionResults."spring.beaninfo.ignore",
                    ignore.toString());
        }
    }

可是這個屬性的做用還真不知道。。

1. 打印banner
2. 根據當前環境建立ApplicationContext

protected ConfigurableApplicationContext createApplicationContext() {
        Class<?> contextClass = this.applicationContextClass;
        if (contextClass == null) {
            try {
                switch (this.webApplicationType) {
                case SERVLET:
                    contextClass = Class.forName(DEFAULT_WEB_CONTEXT_CLASS);
                    break;
                case REACTIVE:
                    contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);
                    break;
                default:
                    contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);
                }
            }
            catch (ClassNotFoundException ex) {
                throw new IllegalStateException(
                        "Unable create a default ApplicationContext, "
                                + "please specify an ApplicationContextClass",
                        ex);
            }
        }
        return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
    }

基於我們的Servlet環境，因此建立的ApplicationContext爲AnnotationConfigServletWebServerApplicationContext

1. 加載SpringBootExceptionReporter，這個類裏包含了SpringBoot啓動失敗後異常處理相關的組件

private <T> Collection<T> getSpringFactoriesInstances(Class<T> type,
            Class<?>[] parameterTypes, Object... args) {
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        Set<String> names = new LinkedHashSet<>(
                SpringFactoriesLoader.loadFactoryNames(type, classLoader));
        List<T> instances = createSpringFactoriesInstances(type, parameterTypes,
                classLoader, args, names);
        AnnotationAwareOrderComparator.sort(instances);
        return instances;
    }

10 prepareContext 這一塊仍是比較長的

private void prepareContext(ConfigurableApplicationContext context,
        ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
        ApplicationArguments applicationArguments, Banner printedBanner) {
    context.setEnvironment(environment);
    postProcessApplicationContext(context);
    applyInitializers(context);
    listeners.contextPrepared(context);
    if (this.logStartupInfo) {
        logStartupInfo(context.getParent() == null);
        logStartupProfileInfo(context);
    }

    context.getBeanFactory().registerSingleton("springApplicationArguments",
            applicationArguments);                               
    if (printedBanner != null) {
        context.getBeanFactory().registerSingleton("springBootBanner", printedBanner);
    }

    // Load the sources
    Set<Object> sources = getAllSources();                     
    Assert.notEmpty(sources, "Sources must not be empty");       
    load(context, sources.toArray(new Object[0]));
    listeners.contextLoaded(context);
}

1. 第一行，將context中相關的environment所有替換

public void setEnvironment(ConfigurableEnvironment environment) {
    super.setEnvironment(environment);            // 設置context的environment
    this.reader.setEnvironment(environment);    // 實例化context的reader屬性的conditionEvaluator屬性
    this.scanner.setEnvironment(environment);    // 設置context的scanner屬性的environment屬性
}

2. 上下文後處理

protected void postProcessApplicationContext(ConfigurableApplicationContext context) {
    if (this.beanNameGenerator != null) {
        context.getBeanFactory().registerSingleton(
                AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR,
                this.beanNameGenerator);
    }
    if (this.resourceLoader != null) {
        if (context instanceof GenericApplicationContext) {
            ((GenericApplicationContext) context)
                    .setResourceLoader(this.resourceLoader);
        }
        if (context instanceof DefaultResourceLoader) {
            ((DefaultResourceLoader) context)
                    .setClassLoader(this.resourceLoader.getClassLoader());
        }
    }
}

這一塊默認beanNameGenerator和resourceLoader都是空的，只有當咱們自定義這兩個對象時纔會把容器內的bean替換

3. 執行全部的`ApplicationContextInitializer`的`initialize`方法

protected void applyInitializers(ConfigurableApplicationContext context) {
    for (ApplicationContextInitializer initializer : getInitializers()) {
        Class<?> requiredType = GenericTypeResolver.resolveTypeArgument(
                initializer.getClass(), ApplicationContextInitializer.class);
        Assert.isInstanceOf(requiredType, context, "Unable to call initializer.");
        initializer.initialize(context);
    }
}

4. `listeners.contextPrepared(context)`這是個空方法，沒有實現，一個Spring的擴展點
5. 打印profile
6. 註冊bean：`springApplicationArguments`
7. 發佈事件

public void contextLoaded(ConfigurableApplicationContext context) {
        for (ApplicationListener<?> listener : this.application.getListeners()) {
            if (listener instanceof ApplicationContextAware) {
                ((ApplicationContextAware) listener).setApplicationContext(context);
            }
            context.addApplicationListener(listener);
        }
        this.initialMulticaster.multicastEvent(
                new ApplicationPreparedEvent(this.application, this.args, context));
    }

這裏不只發佈了ApplicationPreparedEvent事件，還往實現了ApplicationContextAware接口的監聽器中注入了context容器

8. load，其實就是建立了一個`BeanDefinitionLoader`對象

protected void load(ApplicationContext context, Object[] sources) {
        if (logger.isDebugEnabled()) {
            logger.debug(
                    "Loading source " + StringUtils.arrayToCommaDelimitedString(sources));
        }
        BeanDefinitionLoader loader = createBeanDefinitionLoader(
                getBeanDefinitionRegistry(context), sources);
        if (this.beanNameGenerator != null) {
            loader.setBeanNameGenerator(this.beanNameGenerator);
        }
        if (this.resourceLoader != null) {
            loader.setResourceLoader(this.resourceLoader);
        }
        if (this.environment != null) {
            loader.setEnvironment(this.environment);
        }
        loader.load();
    }

1. 容器的初始化refreshContext

這個方法最後仍是調用的AbstractApplicationContext類的refresh方法，因爲篇幅過長這裏就不展開了，感興趣的同窗能夠參考這篇文章：基於註解的SpringIOC源碼解析

public void refresh() throws BeansException, IllegalStateException {
   synchronized (this.startupShutdownMonitor) {
      // 記錄容器的啓動時間、標記「已啓動」狀態、檢查環境變量
      prepareRefresh();
      // 初始化BeanFactory容器、註冊BeanDefinition
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
      // 設置 BeanFactory 的類加載器，添加幾個 BeanPostProcessor，手動註冊幾個特殊的 bean
      prepareBeanFactory(beanFactory);
      try {
         // 擴展點
         postProcessBeanFactory(beanFactory);
         // 調用 BeanFactoryPostProcessor 各個實現類的 postProcessBeanFactory(factory) 方法
         invokeBeanFactoryPostProcessors(beanFactory);
         // 註冊 BeanPostProcessor 的實現類
         registerBeanPostProcessors(beanFactory);
         // 初始化MessageSource
         initMessageSource();
         // 初始化事件廣播器
         initApplicationEventMulticaster();
         // 擴展點
         onRefresh();
         // 註冊事件監聽器
         registerListeners();
         // 初始化全部的 singleton beans
         finishBeanFactoryInitialization(beanFactory);
         // 廣播事件
         finishRefresh();
      }
      catch (BeansException ex) {
         if (logger.isWarnEnabled()) {
            logger.warn("Exception encountered during context initialization - " +
                  "cancelling refresh attempt: " + ex);
         }
         // 銷燬已經初始化的的Bean
         destroyBeans();
         // 設置 'active' 狀態
         cancelRefresh(ex);
         throw ex;
      }
      finally {
         // 清除緩存
         resetCommonCaches();
      }
   }
}

1. afterRefresh

這裏沒有任何實現，Spring留給咱們的擴展點

1. 中止以前啓動的計時裝置，而後發送ApplicationStartedEvent事件
2. 調用系統中ApplicationRunner以及CommandLineRunner接口的實現類，關於這兩個接口的使用能夠參考個人這篇文章：Java項目啓動時執行指定方法的幾種方式

private void callRunners(ApplicationContext context, ApplicationArguments args) {
        List<Object> runners = new ArrayList<>();
        runners.addAll(context.getBeansOfType(ApplicationRunner.class).values());
        runners.addAll(context.getBeansOfType(CommandLineRunner.class).values());
        AnnotationAwareOrderComparator.sort(runners);
        for (Object runner : new LinkedHashSet<>(runners)) {
            if (runner instanceof ApplicationRunner) {
                callRunner((ApplicationRunner) runner, args);
            }
            if (runner instanceof CommandLineRunner) {
                callRunner((CommandLineRunner) runner, args);
            }
        }
    }

1. 異常處理
2. 發送ApplicationReadyEvent事件