在使用SpringBoot之后，启动一个应用变得非常简单。但作为一个有追求的技术人，不仅要会用，还要了解其基本原理。

下面是一个启动类例子，由三部分组成：SpringBootApplication注解，main方法，run方法调用
**

  1. @SpringBootApplication
  2. public class SampleWebApplication {
  4.   public static void main(String[] args) {
  5.     SpringApplication.run(SampleWebApplication.class, args);
  6.   }
  8. }

main 方法这个没什么好说的，名字是别人定好的，启动的时候会执行这个方法。

SpringBootApplication注解

  1. @Target({ElementType.TYPE})
  2. @Retention(RetentionPolicy.RUNTIME)
  3. @Documented
  4. @Inherited
  5. @SpringBootConfiguration
  6. @EnableAutoConfiguration
  7. @ComponentScan(
  8.     excludeFilters = {@Filter(
  9.     type = FilterType.CUSTOM,
  10.     classes = {TypeExcludeFilter.class}
  11. ), @Filter(
  12.     type = FilterType.CUSTOM,
  13.     classes = {AutoConfigurationExcludeFilter.class}
  14. )}
  15. )
  16. public @interface SpringBootApplication {
  17.     //忽略其它代码
  18. }

SpringBootApplication注解其实是SpringBootConfiguration，EnableAutoConfiguration和ComponentScan的复合体。

1.SpringBootConfiguration

其实就是@Configuration,用来表示被标注的类是一个配置类，并将其加载到Spring容器中
**

2.EnableAutoConfiguration

开启SpringBoot自动配置，在程序启动时读取 ClassPath 下面的 META-INF/spring.factories 文件来获取所有导出类，生成默认配置

3.ComponentScan

包扫描注解,默认扫描主类包路径下的类

run的调用过程

run方法本质就是 new SpringApplication 实例，同时调用一下它的run方法

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

构造函数

我们先看一下构造函数的内容

  1. public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
  2.     this.resourceLoader = resourceLoader;
  3.     Assert.notNull(primarySources, "PrimarySources must not be null");
  4.     // 1.主类容器
  5.     this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
  7.     // 2.推断应用类型
  8.     this.webApplicationType = WebApplicationType.deduceFromClasspath();
  10.     // 3.扫描META-INF/spring.factories文件的 ApplicationContextInitializer 并加载
  11.     setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
  13.     // 4.扫描META-INF/spring.factories文件的 ApplicationListener 并加载
  14.     setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
  16.     // 5.保存主类
  17.     this.mainApplicationClass = deduceMainApplicationClass();
  18. }

整个构造过程主要是加载了 ApplicationContextInitializer 和 ApplicationListener

  • ApplicationContextInitializer 初始化了 SpringBoot 上下文 Context，后面会用到
  • ApplicationListener 则是监听 SpringBoot 启动后的事件 onApplicationEvent

加载的配置和内容都在 META-INF/spring.factories 下面

run

我们再看一下实例调用的 run 方法

  1. public ConfigurableApplicationContext run(String... args) {
  2.     // 1.这是一个计时器
  3.     StopWatch stopWatch = new StopWatch();
  4.     stopWatch.start();
  6.     // 2.初始化 context 
  7.     ConfigurableApplicationContext context = null;
  9.     // 3.给用户定制 Exception 错误提示用的，先忽略
  10.     Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
  12.     // 4.设置一些环境变量
  13.     configureHeadlessProperty();
  15.     // 5.获取事件监听器并开始监听
  16.     SpringApplicationRunListeners listeners = getRunListeners(args);
  17.     listeners.starting();
  19.     try {
  20.         // 6.把参数args封装成DefaultApplicationArguments
  21.         ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
  23.         // 7.准备环境信息并和 Spring 上下文绑定
  24.         ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);           
  25.         configureIgnoreBeanInfo(environment);
  27.         // 8.打印banner
  28.         Banner printedBanner = printBanner(environment);
  30.         // 9.创建应用 context
  31.         context = createApplicationContext();
  33.         // 10.获取异常事件监听 
  34.         exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
  35.                                                          new Class[] { ConfigurableApplicationContext.class }, context);
  37.         // 11.把环境信息，监听器，参数，banner和context上下文绑定
  38.         prepareContext(context, environment, listeners, applicationArguments, printedBanner);
  40.         // 12.刷新Context？这个命名我也比较奇怪。在这里是Spring真正的启动处，会去扫描和初始化Bean
  41.         refreshContext(context);
  43.         // 13.一个Refresh结束之后的钩子，什么也没做
  44.         afterRefresh(context, applicationArguments);
  46.         // 14.停止计时
  47.         stopWatch.stop();
  48.         if (this.logStartupInfo) {
  49.             new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
  50.         }
  52.         // 15.监听器 start
  53.         listeners.started(context);
  55.         // 16.调用Context里面的 ApplicationRunner 和 CommandLineRunner
  56.         callRunners(context, applicationArguments);
  57.     }
  58.     catch (Throwable ex) {
  59.         handleRunFailure(context, ex, exceptionReporters, listeners);
  60.         throw new IllegalStateException(ex);
  61.     }
  63.     try {
  64.         // 15.监听器 开始运行
  65.         listeners.running(context);
  66.     }
  67.     catch (Throwable ex) {
  68.         handleRunFailure(context, ex, exceptionReporters, null);
  69.         throw new IllegalStateException(ex);
  70.     }
  71.     return context;
  72. }

整体来说，run是在初始化上下文和绑定一些参数，环境信息等

其中最关键的是 refreshContext ，点击去发现很惊喜，这部分代码注释写得非常好，每一行都有注释…

  1. @Override
  2. public void refresh() throws BeansException, IllegalStateException {
  3.     synchronized (this.startupShutdownMonitor) {
  4.         // Prepare this context for refreshing.
  5.         prepareRefresh();
  7.         // Tell the subclass to refresh the internal bean factory.
  8.         ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
  10.         // Prepare the bean factory for use in this context.
  11.         prepareBeanFactory(beanFactory);
  13.         try {
  14.             // Allows post-processing of the bean factory in context subclasses.
  15.             postProcessBeanFactory(beanFactory);
  17.             // Invoke factory processors registered as beans in the context.
  18.             invokeBeanFactoryPostProcessors(beanFactory);
  20.             // Register bean processors that intercept bean creation.
  21.             registerBeanPostProcessors(beanFactory);
  23.             // Initialize message source for this context.
  24.             initMessageSource();
  26.             // Initialize event multicaster for this context.
  27.             initApplicationEventMulticaster();
  29.             // Initialize other special beans in specific context subclasses.
  30.             // 这里很关键，在创建 web Server
  31.             onRefresh();
  33.             // Check for listener beans and register them.
  34.             registerListeners();
  36.             // Instantiate all remaining (non-lazy-init) singletons.
  37.             finishBeanFactoryInitialization(beanFactory);
  39.             // Last step: publish corresponding event.
  40.             finishRefresh();
  41.         }
  43.         catch (BeansException ex) {
  44.             if (logger.isWarnEnabled()) {
  45.                 logger.warn("Exception encountered during context initialization - " +
  46.                             "cancelling refresh attempt: " + ex);
  47.             }
  49.             // Destroy already created singletons to avoid dangling resources.
  50.             destroyBeans();
  52.             // Reset 'active' flag.
  53.             cancelRefresh(ex);
  55.             // Propagate exception to caller.
  56.             throw ex;
  57.         }
  59.         finally {
  60.             // Reset common introspection caches in Spring's core, since we
  61.             // might not ever need metadata for singleton beans anymore...
  62.             resetCommonCaches();
  63.         }
  64.     }
  65. }

总结：
1、run 方法主要是扫描配置，初始化了应用上下文并加载bean到容器
2、启动Web容器

图解

image.png

参考文章：
Using the @SpringBootApplication Annotation：https://docs.spring.io/spring-boot/docs/current/reference/html/using-spring-boot.html#using-boot-using-springbootapplication-annotation
SpringBoot启动流程总结: https://blog.csdn.net/mnicsm/article/details/93893669