【SpringBoot】SpringBoot 启动原理（十五）

　　此系列前面章节介绍的SpringBoot的使用，本章结束SpringBoot启动原理

　　通过搭建一个SpringBoot Web工程，然后采用Debug模式运行程序，一步一步参考程序究竟做了哪些任务

　　本篇文章所用到的 Spring Boot版本是 2.1.8.RELEASE

SpringApplication 准备阶段

　　1、搭建SpringBoot Web工程，参考【SpringBoot】SpringBoot Web开发（八）；

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <project xmlns="http://maven.apache.org/POM/4.0.0"
 3          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 5     <modelVersion>4.0.0</modelVersion>
 6 
 7     <groupId>com.test</groupId>
 8     <artifactId>test-springboot-web2</artifactId>
 9     <version>1.0-SNAPSHOT</version>
10 
11     <parent>
12         <groupId>org.springframework.boot</groupId>
13         <artifactId>spring-boot-starter-parent</artifactId>
14         <version>2.1.8.RELEASE</version>
15     </parent>
16 
17     <properties>
18 
19         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
20         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
21         <java.version>1.8</java.version>
22     </properties>
23 
24     <dependencies>
25 
26         <dependency>
27             <groupId>org.springframework.boot</groupId>
28             <artifactId>spring-boot-starter-web</artifactId>
29         </dependency>
30 
31     </dependencies>
32 
33 
34     <!-- SpringBoot打包插件，可以将代码打包成一个可执行的jar包 -->
35     <build>
36         <plugins>
37             <plugin>
38                 <groupId>org.springframework.boot</groupId>
39                 <artifactId>spring-boot-maven-plugin</artifactId>
40             </plugin>
41         </plugins>
42     </build>
43 
44 </project>

View Code

　　2、使用Debug模式运行程序、

 1 @SpringBootApplication
 2 public class Application {
 3 
 4     public static void main(String[] args){
 5         // 调用SpringApplication的静态run方法
 6         // 参数是主类 和 运行参数args
 7         SpringApplication.run(Application.class, args);
 8 
 9     }
10 
11 }

　　3、查看SpringApplication的run方法，通过入参 primarySources 构造 SpringApplication 类，然后在调用 run 方法，其中，准备阶段的工作皆在 SpringApplication 的构造器中处理：

1 public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
2     return run(new Class<?>[] { primarySource }, args);
3 }
4 
5 public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
6     return new SpringApplication(primarySources).run(args);
7 }

SpringApplication构造方法

　　查看SpringApplication的构造方法，构造流程如下：

 1 public class SpringApplication {
 2 
 3     ...
 4 
 5     private Set<Class<?>> primarySources;
 6 
 7     private Set<String> sources = new LinkedHashSet<>();
 8 
 9     private Class<?> mainApplicationClass;
10 
11     private WebApplicationType webApplicationType;
12 
13     private List<ApplicationContextInitializer<?>> initializers;
14 
15     private List<ApplicationListener<?>> listeners;
16 
17     public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
18 
19         // resourceLoader 主要用来获取 Resource 及 ClassLoader。这里值为 null
20         this.resourceLoader = resourceLoader;
21 
22         // 断言主要加载资源类不能为 null，否则报错
23         Assert.notNull(primarySources, "PrimarySources must not be null");
24 
25         // primarySources是SpringApplication.run的参数，存放的是主配置类
26         this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
27 
28         // 进行Web应用的类型推断
29         this.webApplicationType = WebApplicationType.deduceFromClasspath();
30 
31         // 加载应用上下文初始化器 initializer
32         setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
33         
34         // 加载应用事件监听器 listener
35         setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
36         
37         // 推断引导类，也就是找到入口类
38         this.mainApplicationClass = deduceMainApplicationClass();
39     }
40 
41     ...
42 
43 }

　　SpringApplication构造方法中主要做了4件事

　　1、推断 Web 应用类型

　　SpringApplication允许指定应用的类型，大体上包括Web应用和非Web应用。从 Spring Boot 2.0开始，Web应用又可分为Servlet Web和Reactive Web。而在准备阶段，是通过检查当前ClassPath下某些Class是否存在，从而推导应用的类型。我们进入 WebApplicationType.deduceFromClasspath() 方法查看：

 1 public enum WebApplicationType {
 2 
 3     /**
 4      * 非 web 项目
 5      */
 6     NONE,
 7 
 8     /**
 9      * servlet web 项目
10      */
11     SERVLET,
12 
13     /**
14      * reactive web 项目
15      */
16     REACTIVE;
17 
18     private static final String[] SERVLET_INDICATOR_CLASSES = { "javax.servlet.Servlet",
19             "org.springframework.web.context.ConfigurableWebApplicationContext" };
20 
21     private static final String WEBMVC_INDICATOR_CLASS = "org.springframework." + "web.servlet.DispatcherServlet";
22 
23     private static final String WEBFLUX_INDICATOR_CLASS = "org." + "springframework.web.reactive.DispatcherHandler";
24 
25     private static final String JERSEY_INDICATOR_CLASS = "org.glassfish.jersey.servlet.ServletContainer";
26 
27     private static final String SERVLET_APPLICATION_CONTEXT_CLASS = "org.springframework.web.context.WebApplicationContext";
28 
29     private static final String REACTIVE_APPLICATION_CONTEXT_CLASS = "org.springframework.boot.web.reactive.context.ReactiveWebApplicationContext";
30 
31     static WebApplicationType deduceFromClasspath() {
32         // 根据是否存在某些类，判断是否是reactive web 项目
33         if (ClassUtils.isPresent(WEBFLUX_INDICATOR_CLASS, null) && !ClassUtils.isPresent(WEBMVC_INDICATOR_CLASS, null)
34                 && !ClassUtils.isPresent(JERSEY_INDICATOR_CLASS, null)) {
35             return WebApplicationType.REACTIVE;
36         }
37         // 根据是否存在某些类，判断是否是非 web 项目
38         for (String className : SERVLET_INDICATOR_CLASSES) {
39             if (!ClassUtils.isPresent(className, null)) {
40                 return WebApplicationType.NONE;
41             }
42         }
43         // 默认为 servlet web 项目
44         return WebApplicationType.SERVLET;
45     }
46 
47     ...
48 
49 }

　　可以看到，在方法中利用 ClassUtils.isPresent 进行判断， 当DispatcherHandler存在，而DispatcherServlet和ServletContainer不存在时，则当前应用推导为 Reactive web 类型；当 Servlet 和 ConfigurableWebApplicationContext 不存在时，当前应用为非 Web 类型；其他的则为 Servlet Web 类型。

　　2、加载应用上下文初始化器 initializer

　　　　a、进入加载Spring应用上下文初始器的过程  setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class))：

 1 public class SpringApplication {
 2 
 3     ...
 4 
 5     /**
 6      * 加载应用上下文初始化器 initializer
 7      */
 8     public void setInitializers(Collection<? extends ApplicationContextInitializer<?>> initializers) {
 9         this.initializers = new ArrayList<>();
10         this.initializers.addAll(initializers);
11     }
12 
13     public void addInitializers(ApplicationContextInitializer<?>... initializers) {
14         this.initializers.addAll(Arrays.asList(initializers));
15     }
16 
17     /**
18      * 通过 Spring 工厂加载机制获取 ApplicationContextInitializer 初始器  
19      */
20     private <T> Collection<T> getSpringFactoriesInstances(Class<T> type) {
21         return getSpringFactoriesInstances(type, new Class<?>[] {});
22     }
23 
24     private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
25         ClassLoader classLoader = getClassLoader();
26         // Use names and ensure unique to protect against duplicates
27         Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
28         List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
29         AnnotationAwareOrderComparator.sort(instances);
30         return instances;
31     }
32 
33     ...
34     
35 }

　　　　b、可以看到，通过SpringFactoriesLoader.loadFactoryNames(type, classLoader)，获取资源地址

 1 public final class SpringFactoriesLoader {
 2 
 3     /**
 4      * 默认工厂资源地址
 5      */
 6     public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
 7 
 8     private static final Log logger = LogFactory.getLog(SpringFactoriesLoader.class);
 9 
10     private static final Map<ClassLoader, MultiValueMap<String, String>> cache = new ConcurrentReferenceHashMap<>();
11 
12     ...
13 
14     public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
15         String factoryClassName = factoryClass.getName();
16         return loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
17     }
18 
19     private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
20         MultiValueMap<String, String> result = cache.get(classLoader);
21         if (result != null) {
22             return result;
23         }
24 
25         try {
26             // META-INF/spring.factories 资源中获取url
27             Enumeration<URL> urls = (classLoader != null ?
28                     classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
29                     ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
30             result = new LinkedMultiValueMap<>();
31             while (urls.hasMoreElements()) {
32                 URL url = urls.nextElement();
33                 UrlResource resource = new UrlResource(url);
34                 Properties properties = PropertiesLoaderUtils.loadProperties(resource);
35                 for (Map.Entry<?, ?> entry : properties.entrySet()) {
36                     String factoryClassName = ((String) entry.getKey()).trim();
37                     for (String factoryName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) {
38                         result.add(factoryClassName, factoryName.trim());
39                     }
40                 }
41             }
42             cache.put(classLoader, result);
43             return result;
44         }
45         catch (IOException ex) {
46             throw new IllegalArgumentException("Unable to load factories from location [" +
47                     FACTORIES_RESOURCE_LOCATION + "]", ex);
48         }
49     }
50 
51     ...
52 
53 }

 　　　　c、可以看到，这里是通过 Spring 工厂加载机制 SpringFactoriesLoader.loadFactoryNames(type, classLoader) 方法获取。该方法是从所有的 META-INF/spring.factories 资源中获取key为 ApplicationContextInitializer 的实现类集合，如下是 spring-boot-autoconfigure 包下的 spring.factories 文件：

1 # Initializers
2 org.springframework.context.ApplicationContextInitializer=\
3 org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,\
4 org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener

　　　　d、这里获取的就是 SharedMetadataReaderFactoryContextInitializer 和 ConditionEvaluationReportLoggingListener 上下文初始化器，接下来通过 createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names) 方法初始化这些实现类：

 1 private <T> List<T> createSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes,
 2         ClassLoader classLoader, Object[] args, Set<String> names) {
 3     List<T> instances = new ArrayList<>(names.size());
 4     for (String name : names) {
 5         try {
 6             Class<?> instanceClass = ClassUtils.forName(name, classLoader);
 7             Assert.isAssignable(type, instanceClass);
 8             Constructor<?> constructor = instanceClass.getDeclaredConstructor(parameterTypes);
 9             T instance = (T) BeanUtils.instantiateClass(constructor, args);
10             instances.add(instance);
11         }
12         catch (Throwable ex) {
13             throw new IllegalArgumentException("Cannot instantiate " + type + " : " + name, ex);
14         }
15     }
16     return instances;
17 }

　　　　e、这里先通过 BeanUtils.instantiate 初始化这些类，然后将初始化的类保存至List进行返回，并进行排序操作，最后添加到SpringApplication的initializers集合变量中。至此，该流程结束。

　　　　查看SharedMetadataReaderFactoryContextInitializer类

 1 class SharedMetadataReaderFactoryContextInitializer
 2         implements ApplicationContextInitializer<ConfigurableApplicationContext>, Ordered {
 3 
 4     @Override
 5     public void initialize(ConfigurableApplicationContext applicationContext) {
 6         applicationContext.addBeanFactoryPostProcessor(new CachingMetadataReaderFactoryPostProcessor());
 7     }
 8 
 9     ...
10 
11 }

　　　　可以看到该类实现了 Spring 的 ApplicationContextInitializer 接口，并重写了initialize()方法。同理，其他的 Initializer 接口也是类似实现。 而在这里则是在上下文中加入了 CachingMetadataReaderFactoryPostProcessor bean工厂后置处理器。

　　　　注：

ApplicationContextInitializer 接口的主要作用是在 ConfigurableApplicationContext#refresh() 方法调用之前做一些初始化工作。

　　3、加载应用事件监听器 listener

　　　　a、接着加载应用事件监听器 setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class))，过程与“加载应用上下文初始器”基本一致，同样是调用 getSpringFactoriesInstances 方法，不过这里获取的是 key 为 ApplicationListener 的对象集合，如下是 spring-boot-autoconfigure 包下的 spring.factories 文件：：

1 # Application Listeners
2 org.springframework.context.ApplicationListener=\
3 org.springframework.boot.autoconfigure.BackgroundPreinitializer

　　　　b、最后，将获取的 BackgroundPreinitializer 对象通过 setListeners 方法放入 listeners 属性变量中：

1 public void setListeners(Collection<? extends ApplicationListener<?>> listeners) {
2     this.listeners = new ArrayList<>();
3     this.listeners.addAll(listeners);
4 }

　　　　c、查看监听器中的内容，如BackgroundPreinitializer

 1 public class BackgroundPreinitializer implements ApplicationListener<SpringApplicationEvent> {
 2 
 3     @Override
 4     public void onApplicationEvent(SpringApplicationEvent event) {
 5         if (!Boolean.getBoolean(IGNORE_BACKGROUNDPREINITIALIZER_PROPERTY_NAME)
 6                 && event instanceof ApplicationStartingEvent && preinitializationStarted.compareAndSet(false, true)) {
 7             performPreinitialization();
 8         }
 9         if ((event instanceof ApplicationReadyEvent || event instanceof ApplicationFailedEvent)
10                 && preinitializationStarted.get()) {
11             try {
12                 preinitializationComplete.await();
13             }
14             catch (InterruptedException ex) {
15                 Thread.currentThread().interrupt();
16             }
17         }
18     }
19 
20     ...
21 
22 }

 　　　　可以看到，该类实现了 Spring 的 ApplicationListener 接口，在重写的 onApplicationEvent 方法中触发相应的事件进行操作。同理，其他 Listener 也是类似实现。而该接口的主要功能是另起一个后台线程触发那些耗时的初始化，包括验证器、消息转换器等等。

　　　　注：

目前spring boot中支持的事件类型如下：

ApplicationFailedEvent：该事件为spring boot启动失败时的操作
ApplicationPreparedEvent：上下文context准备时触发
ApplicationReadyEvent：上下文已经准备完毕的时候触发
ApplicationStartedEvent：spring boot 启动监听类
SpringApplicationEvent：获取SpringApplication
ApplicationEnvironmentPreparedEvent：环境事先准备

　　4、推断引导类

　　　　准备阶段的最后一步是推断应用的引导类，也就是获取启动 main 方法的类，执行的是 deduceMainApplicationClass() 方法：

 1 private Class<?> deduceMainApplicationClass() {
 2     try {
 3         StackTraceElement[] stackTrace = new RuntimeException().getStackTrace();
 4         for (StackTraceElement stackTraceElement : stackTrace) {
 5             if ("main".equals(stackTraceElement.getMethodName())) {
 6                 return Class.forName(stackTraceElement.getClassName());
 7             }
 8         }
 9     }
10     catch (ClassNotFoundException ex) {
11         // Swallow and continue
12     }
13     return null;
14 }

　　　　可以看到，通过 getStackTrace()方法获取当前线程的执行栈，再通过 getMethodName()获取方法名，判断是否是 main 方法，最后返回 main 方法的所在类。

SpringApplication run方法

　　查看SpringApplication的run方法，流程如下：

 1 public class SpringApplication {
 2 
 3     ...
 4 
 5     public ConfigurableApplicationContext run(String... args) {
 6         // 开关
 7         StopWatch stopWatch = new StopWatch();
 8 
 9         // 开始
10         stopWatch.start();
11 
12         ConfigurableApplicationContext context = null;
13         Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
14         configureHeadlessProperty();
15 
16         // 获取SpringApplicationRunListeners;从类路径下META‐INF/spring.factories
17         SpringApplicationRunListeners listeners = getRunListeners(args);
18 
19         // 回调所有的获取SpringApplicationRunListener.starting()方法
20         listeners.starting();
21 
22         try {
23             // 封装命令行参数
24             ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
25 
26             // 准备环境
27             // 创建环境完成后回调SpringApplicationRunListener.environmentPrepared();
28             ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
29             configureIgnoreBeanInfo(environment);
30  
31             // 打印 Banner
32             Banner printedBanner = printBanner(environment);
33 
34             // 通过 createApplicationContext 方法创建上下文，
35             // 根据 Web 环境不同创建的上下文也不同
36             context = createApplicationContext();
37             
38             // 异常报告
39             exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
40                     new Class[] { ConfigurableApplicationContext.class }, context);
41             
42             // 准备上下文环境;将environment保存到ioc中;而且applyInitializers(); 
43             // applyInitializers():回调之前保存的所有的ApplicationContextInitializer的initialize方法 
44             // 回调所有的SpringApplicationRunListener的contextPrepared();
45             prepareContext(context, environment, listeners, applicationArguments, printedBanner);
46 
47             // 刷新容器;ioc容器初始化(如果是web应用还会创建嵌入式的Tomcat);
48             // 扫描，创建，加载所有组件的地方;(配置类，组件，自动配置)
49             refreshContext(context);
50 
51             // 刷新之后回调方法
52             afterRefresh(context, applicationArguments);
53 
54             // 结束
55             stopWatch.stop();
56             if (this.logStartupInfo) {
57                 new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
58             }
59 
60             // 回调所有的获取SpringApplicationRunListener.started()方法
61             listeners.started(context);
62 
63             // 从ioc容器中获取所有的ApplicationRunner和CommandLineRunner进行回调
64             // ApplicationRunner先回调，CommandLineRunner再回调
65             callRunners(context, applicationArguments);
66         }
67         catch (Throwable ex) {
68             handleRunFailure(context, ex, exceptionReporters, listeners);
69             throw new IllegalStateException(ex);
70         }
71 
72         try {
73             listeners.running(context);
74         }
75         catch (Throwable ex) {
76             handleRunFailure(context, ex, exceptionReporters, null);
77             throw new IllegalStateException(ex);
78         }
79         return context;
80     }
81 
82     ...
83 
84 } 

　　1、加载SpringApplicationRunListener

　　　　查看代码getRunListeners(args)；

1 private SpringApplicationRunListeners getRunListeners(String[] args) {
2     Class<?>[] types = new Class<?>[] { SpringApplication.class, String[].class };
3     return new SpringApplicationRunListeners(logger,
4             getSpringFactoriesInstances(SpringApplicationRunListener.class, types, this, args));
5 }

　　　　可以看出获取SpringApplicationRunListeners；也是从类路径下META‐INF/spring.factories

　　　　获取完成之后回到SpringApplicationRunListeners的start()方法，listeners.starting();

　　2、准备环境

　　　　调用方法prepareEnvironment(listeners, applicationArguments);

 1 private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
 2         ApplicationArguments applicationArguments) {
 3     // 创建并配置环境
 4     ConfigurableEnvironment environment = getOrCreateEnvironment();
 5     configureEnvironment(environment, applicationArguments.getSourceArgs());
 6     ConfigurationPropertySources.attach(environment);
 7 
 8     // 回调listeners的环境准备完成方法
 9     listeners.environmentPrepared(environment);
10     bindToSpringApplication(environment);
11     if (!this.isCustomEnvironment) {
12         environment = new EnvironmentConverter(getClassLoader()).convertEnvironmentIfNecessary(environment,
13                 deduceEnvironmentClass());
14     }
15     ConfigurationPropertySources.attach(environment);
16     return environment;
17 }
18 
19 
20 
21 private ConfigurableEnvironment getOrCreateEnvironment() {
22     if (this.environment != null) {
23         return this.environment;
24     }
25     // 根据webApplicationType类型判断，创建相应环境
26     // webApplicationType类型在准备阶段已赋值
27     switch (this.webApplicationType) {
28     case SERVLET:
29         return new StandardServletEnvironment();
30     case REACTIVE:
31         return new StandardReactiveWebEnvironment();
32     default:
33         return new StandardEnvironment();
34     }
35 }

 　　可以看到，通过getOrCreateEnvironment();获取环境对象，而获取的依据又是webApplicationType，webApplicationType类型在准备阶段已赋值，然后又回调了listeners的环境准备完成方法　

　　3、创建上下文环境

　　　　调用方法createApplicationContext();来创建上下文

 1 protected ConfigurableApplicationContext createApplicationContext() {
 2     Class<?> contextClass = this.applicationContextClass;
 3     if (contextClass == null) {
 4         try {
 5             switch (this.webApplicationType) {
 6             case SERVLET:
 7                 contextClass = Class.forName(DEFAULT_SERVLET_WEB_CONTEXT_CLASS);
 8                 break;
 9             case REACTIVE:
10                 contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);
11                 break;
12             default:
13                 contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);
14             }
15         }
16         catch (ClassNotFoundException ex) {
17             throw new IllegalStateException(
18                     "Unable create a default ApplicationContext, " + "please specify an ApplicationContextClass",
19                     ex);
20         }
21     }
22     return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
23 }

　　　　可以看到，根据 Web 环境不同创建的上下文也不同

　　4、准备上下文环境

　　　　调用方法：prepareContext(context, environment, listeners, applicationArguments, printedBanner)；准备上下文

private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment,
        SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {
    context.setEnvironment(environment);
    postProcessApplicationContext(context);
    applyInitializers(context);

    // 调用listeners上下文准备完成方法
    listeners.contextPrepared(context);
    if (this.logStartupInfo) {
        logStartupInfo(context.getParent() == null);
        logStartupProfileInfo(context);
    }
    // 获取Bean工厂
    ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
    // 注册一些组件
    beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
    if (printedBanner != null) {
        beanFactory.registerSingleton("springBootBanner", printedBanner);
    }
    if (beanFactory instanceof DefaultListableBeanFactory) {
        ((DefaultListableBeanFactory) beanFactory)
                .setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
    }
    // 加载资源
    Set<Object> sources = getAllSources();
    Assert.notEmpty(sources, "Sources must not be empty");
    load(context, sources.toArray(new Object[0]));

    // 调用listeners上下文加载完成方法
    listeners.contextLoaded(context);
}

　　5、刷新容器

　　　　通过调试refresh方法，进入 refreshContext 方法，里面调用了 refresh 方法

 1 private void refreshContext(ConfigurableApplicationContext context) {
 2     refresh(context);
 3     if (this.registerShutdownHook) {
 4         try {
 5             context.registerShutdownHook();
 6         }
 7         catch (AccessControlException ex) {
 8             // Not allowed in some environments.
 9         }
10     }
11 }

　　　　这里，最终也是调用 ApplicationContext 的 refresh 方法来启动上下文

1 protected void refresh(ApplicationContext applicationContext) {
2     Assert.isInstanceOf(AbstractApplicationContext.class, applicationContext);
3     ((AbstractApplicationContext) applicationContext).refresh();
4 }

　　　　最终都是调用上下文中的 refresh 方法来启动。该方法是 ApplicationContext 的核心，如 Bean 注册、注入、解析 XML 、解析注解等是从该方法开始，其内部实现大致如下：

 1 public void refresh() throws BeansException, IllegalStateException {
 2     synchronized (this.startupShutdownMonitor) {
 3         // 1. 初始化 refresh 的上下文环境，就是记录下容器的启动时间、标记已启动状态、处理配置文件中的占位符
 4         prepareRefresh();
 5 
 6         // 2. 初始化 BeanFactory，加载并解析配置
 7         ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
 8 
 9         /* ---至此，已经完成了简单容器的所有功能，下面开始对简单容器进行增强--- */
10 
11         // 3. 对 BeanFactory 进行功能增强，如设置BeanFactory的类加载器，添加几个 BeanPostProcessor，手动注册几个特殊的 bean
12         prepareBeanFactory(beanFactory);
13 
14         try {
15             // 4. 后置处理 beanFactory，交由子类实现
16             postProcessBeanFactory(beanFactory);
17 
18             // 5. 调用已注册的 BeanFactoryPostProcessor
19             invokeBeanFactoryPostProcessors(beanFactory);
20 
21             // 6. 注册 BeanPostProcessor，仅仅是注册，调用在getBean的时候
22             registerBeanPostProcessors(beanFactory);
23 
24             // 7. 初始化国际化资源
25             initMessageSource();
26 
27             // 8. 初始化事件广播器
28             initApplicationEventMulticaster();
29 
30             // 9. 留给子类实现的模板方法
31             onRefresh();
32 
33             // 10. 注册事件监听器
34             registerListeners();
35 
36             // 11. 实例化所有非延迟加载的单例
37             finishBeanFactoryInitialization(beanFactory);
38 
39             // 12. 完成刷新过程，发布应用事件
40             finishRefresh();
41             
42         } catch (BeansException ex) {
43             if (logger.isWarnEnabled()) {
44                 logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + ex);
45             }
46             
47             // 13.销毁已经初始化的 singleton 的 Beans，以免有些 bean 会一直占用资源
48             this.destroyBeans();
49             
50             // Reset 'active' flag.
51             this.cancelRefresh(ex);
52             // Propagate exception to caller.
53             throw ex;
54         } finally {
55             // Reset common introspection caches in Spring's core, since we
56             // might not ever need metadata for singleton beans anymore...
57             this.resetCommonCaches();
58         }
59     }
60 }

　　6、刷新之后回调方法

　　　　查看afterRefresh(context, applicationArguments);

1 protected void afterRefresh(ConfigurableApplicationContext context, ApplicationArguments args) {
2 }        

　　　　可以看到里面是空方法，如有需要可以自定义一些内容

　　7、回调Runners

　　　　查看callRunners(context, applicationArguments);

 1 private void callRunners(ApplicationContext context, ApplicationArguments args) {
 2     List<Object> runners = new ArrayList<>();
 3     runners.addAll(context.getBeansOfType(ApplicationRunner.class).values());
 4     runners.addAll(context.getBeansOfType(CommandLineRunner.class).values());
 5     AnnotationAwareOrderComparator.sort(runners);
 6     for (Object runner : new LinkedHashSet<>(runners)) {
 7         if (runner instanceof ApplicationRunner) {
 8             callRunner((ApplicationRunner) runner, args);
 9         }
10         if (runner instanceof CommandLineRunner) {
11             callRunner((CommandLineRunner) runner, args);
12         }
13     }
14 }

 　　　　可以看到，从ioc容器中获取所有的ApplicationRunner和CommandLineRunner进行回调 ，ApplicationRunner先回调，CommandLineRunner再回调

　　　　最后返回上下文context