springboot启动流程 (1) 流程概览

本文将通过阅读源码方式分析SpringBoot应用的启动流程，不涉及Spring启动部分(有相应的文章介绍)。
本文不会对各个流程做展开分析，后续会有文章介绍详细流程。
SpringApplication类

应用启动入口

使用以下方式启动一个SpringBoot应用：

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

复制代码

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. }
9. public ConfigurableApplicationContext run(String... args) {
10.         StopWatch stopWatch = new StopWatch();
11.         stopWatch.start();
12.         ConfigurableApplicationContext context = null;
13.         Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
14.         configureHeadlessProperty();
15.         SpringApplicationRunListeners listeners = getRunListeners(args);
16.         listeners.starting();
17.         try {
18.                 ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
19.                 // 获取应用env
20.                 ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
21.                 configureIgnoreBeanInfo(environment);
22.                 // 打印banner
23.                 Banner printedBanner = printBanner(environment);
24.                 // 创建ApplicationContext
25.                 context = createApplicationContext();
26.                 exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
27.                                 new Class[] { ConfigurableApplicationContext.class }, context);
28.                 // 一些准备工作
29.                 prepareContext(context, environment, listeners, applicationArguments, printedBanner);
30.                 // refresh ApplicationContext
31.                 refreshContext(context);
32.                 afterRefresh(context, applicationArguments);
33.                 stopWatch.stop();
34.                 if (this.logStartupInfo) {
35.                         new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
36.                 }
37.                 // 调用listener
38.                 listeners.started(context);
39.                 // 调用ApplicationRunner和CommandLineRunner
40.                 callRunners(context, applicationArguments);
41.         } catch (Throwable ex) {
42.                 handleRunFailure(context, ex, exceptionReporters, listeners);
43.                 throw new IllegalStateException(ex);
44.         }
46.         try {
47.                 listeners.running(context);
48.         } catch (Throwable ex) {
49.                 handleRunFailure(context, ex, exceptionReporters, null);
50.                 throw new IllegalStateException(ex);
51.         }
52.         return context;
53. }

复制代码

获取应用env

1. private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
2.                 ApplicationArguments applicationArguments) {
3.         // 创建StandardServletEnvironment, 会初始化四个PropertySource:
4.         // servletConfigInitParams, servletContextInitParams, systemProperties, systemEnvironment
5.         // 比如-Dserver.port=8888会在systemProperties中
6.         ConfigurableEnvironment environment = getOrCreateEnvironment();
7.         // 添加defaultProperties和命令行配置参数即CommandLinePropertySource
8.         // 通常都没有这两个配置
9.         configureEnvironment(environment, applicationArguments.getSourceArgs());
10.         // 使用ConfigurationPropertySourcesPropertySource封装并暴露所有的PropertySource集
11.         ConfigurationPropertySources.attach(environment);
12.         // 添加ApplicationEnvironmentPreparedEvent事件并触发multicastEvent加载应用配置文件
13.         listeners.environmentPrepared(environment);
14.         // 将spring.main.xx配置加载到SpringApplication对象
15.         bindToSpringApplication(environment);
16.         if (!this.isCustomEnvironment) {
17.                 environment = new EnvironmentConverter(getClassLoader()).convertEnvironmentIfNecessary(environment,
18.                                 deduceEnvironmentClass());
19.         }
20.         ConfigurationPropertySources.attach(environment);
21.         return environment;
22. }

复制代码

加载配置文件的入口在ConfigFileApplicationListener类中：

1. public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) {
2.         addPropertySources(environment, application.getResourceLoader());
3. }
5. protected void addPropertySources(ConfigurableEnvironment environment, ResourceLoader resourceLoader) {
6.         // 添加RandomValuePropertySource
7.         RandomValuePropertySource.addToEnvironment(environment);
8.         // 加载配置文件
9.         new Loader(environment, resourceLoader).load();
10. }

复制代码

加载配置文件的源码较多，此处不做记录，简单梳理一下流程：

• 加载active profile配置文件
  
  
  
  • 如果配置了spring.config.additional-location或spring.config.location参数，会使用它们作为配置文件。如果这两个参数值是目录，则会从这两个目录下查找配置文件
    
  • 默认从classpath:/,classpath:/config/,file:./,file:./config/*/,file:./config/目录下查找application-xx.properties或application-xx.yml文件
    
  • 使用PropertiesPropertySourceLoader和YamlPropertySourceLoader解析配置文件
    
  • 会将配置参数封装成OriginTrackedMapPropertySource类型对象，使用applicationConfig: [classpath:/application-dev.yml]之类的字符串作为PropertySource的名称
    
  
  
• 加载默认的application.properties或application.yml文件
  
• 解析出来的所有PropertySource都会添加到environment的propertySources中，propertySources是一个MutablePropertySources对象，管理着所有的PropertySource集，在这个过程中，添加的先后顺序决定了配置的优先级
  

创建ApplicationContext

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

复制代码

prepareContext

1. private void prepareContext(
2.                 ConfigurableApplicationContext context, ConfigurableEnvironment environment,
3.                 SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments,
4.                 Banner printedBanner) {
5.         context.setEnvironment(environment);
6.         postProcessApplicationContext(context);
7.         // Apply any ApplicationContextInitializers to the context before it is refreshed.
8.         // ApplicationContextInitializers集是在创建SpringApplication对象的时候初始化的
9.         applyInitializers(context);
10.         // 触发contextPrepared事件
11.         listeners.contextPrepared(context);
12.         if (this.logStartupInfo) {
13.                 logStartupInfo(context.getParent() == null);
14.                 logStartupProfileInfo(context);
15.         }
16.         // 获取BeanFactory并注册必要的Bean
17.         ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
18.         // 注册启动参数
19.         beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
20.         // 注册banner printer
21.         if (printedBanner != null) {
22.                 beanFactory.registerSingleton("springBootBanner", printedBanner);
23.         }
24.         // 设置是否允许Bean覆盖，使用spring.main.allowBeanDefinitionOverriding参数配置
25.         if (beanFactory instanceof DefaultListableBeanFactory) {
26.                 ((DefaultListableBeanFactory) beanFactory)
27.                                 .setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
28.         }
29.         if (this.lazyInitialization) {
30.                 context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
31.         }
32.         // Load the sources
33.         Set<Object> sources = getAllSources();
34.         // 将SpringApplication.run(Xxx.class, args)方法传入的Class注册到容器
35.         // 使用AnnotatedBeanDefinitionReader.register(Class<?>...)方法注册启动类
36.         load(context, sources.toArray(new Object[0]));
37.         // 触发contextLoaded事件
38.         listeners.contextLoaded(context);
39. }

复制代码

refreshApplicationContext

1. protected void refresh(ConfigurableApplicationContext applicationContext) {
2.         applicationContext.refresh();
3. }

复制代码

调用的是ServletWebServerApplicationContext的refresh方法：

1. public final void refresh() throws BeansException, IllegalStateException {
2.         try {
3.                 super.refresh();
4.         } catch (RuntimeException ex) {
5.                 // 关闭web server
6.                 WebServer webServer = this.webServer;
7.                 if (webServer != null) {
8.                         webServer.stop();
9.                 }
10.                 throw ex;
11.         }
12. }

复制代码

绝大多数的refresh逻辑都在AbstractApplicationContext类里面，ServletWebServerApplicationContext中会在onRefresh阶段创建webServer：

1. protected void onRefresh() {
2.         super.onRefresh();
3.         try {
4.                 createWebServer();
5.         } catch (Throwable ex) {
6.                 throw new ApplicationContextException("Unable to start web server", ex);
7.         }
8. }

复制代码

调用ApplicationRunner和CommandLineRunner

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

复制代码

SpringBootApplication注解

指示一个配置类，该类声明一个或多个@Bean方法，并触发自动配置和组件扫描。这是一个方便的注解，相当于声明@Configuration、@EnableAutoConfiguration和@ComponentScan注解。

1. @SpringBootConfiguration
2. @EnableAutoConfiguration
3. @ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
4.                 @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
5. public @interface SpringBootApplication {
7.         /**
8.          * Exclude specific auto-configuration classes such that they will never be applied.
9.          */
10.         @AliasFor(annotation = EnableAutoConfiguration.class)
11.         Class<?>[] exclude() default {};
13.         /**
14.          * Exclude specific auto-configuration class names such that they will never be
15.          * applied.
16.          */
17.         @AliasFor(annotation = EnableAutoConfiguration.class)
18.         String[] excludeName() default {};
20.         /**
21.          * Base packages to scan for annotated components. Use scanBasePackageClasses
22.          * for a type-safe alternative to String-based package names.
23.          */
24.         @AliasFor(annotation = ComponentScan.class, attribute = "basePackages")
25.         String[] scanBasePackages() default {};
27.         /**
28.          * Type-safe alternative to scanBasePackages for specifying the packages to
29.          * scan for annotated components. The package of each class specified will be scanned.
30.          */
31.         @AliasFor(annotation = ComponentScan.class, attribute = "basePackageClasses")
32.         Class<?>[] scanBasePackageClasses() default {};
34.         /**
35.          * The BeanNameGenerator class to be used for naming detected components
36.          * within the Spring container.
37.          */
38.         @AliasFor(annotation = ComponentScan.class, attribute = "nameGenerator")
39.         Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;
41.         /**
42.          * Specify whether @Bean methods should get proxied in order to enforce
43.          * bean lifecycle behavior, e.g. to return shared singleton bean instances even in
44.          * case of direct @Bean method calls in user code. This feature requires
45.          * method interception, implemented through a runtime-generated CGLIB subclass which
46.          * comes with limitations such as the configuration class and its methods not being
47.          * allowed to declare final.
48.          */
49.         @AliasFor(annotation = Configuration.class)
50.         boolean proxyBeanMethods() default true;
51. }

复制代码

AutoConfigurationPackage注解

Registers packages with AutoConfigurationPackages. When no base packages or base package classes are specified, the package of the annotated class is registered.

1. @Configuration
2. public @interface SpringBootConfiguration {
4.         @AliasFor(annotation = Configuration.class)
5.         boolean proxyBeanMethods() default true;
6. }

复制代码

AutoConfigurationImportSelector类

DeferredImportSelector接口的实现类，处理自动装配，导出所有需要自动装配的类。
创建WebServer

SpringBoot会在onRefresh阶段创建webServer，首先从spring容器获取ServletWebServerFactory，然后调用getWebServer方法创建webServer。
getWebServer方法需要传入ServletContextInitializer集来初始化ServletContext。

1. @AutoConfigurationPackage
2. @Import(AutoConfigurationImportSelector.class)
3. public @interface EnableAutoConfiguration {
5.         /**
6.          * Exclude specific auto-configuration classes such that they will never be applied.
7.          */
8.         Class<?>[] exclude() default {};
10.         /**
11.          * Exclude specific auto-configuration class names such that they will never be
12.          * applied.
13.          * 当类路径下没有指定的类时，可以使用这个属性指定排除的类
14.          */
15.         String[] excludeName() default {};
16. }

复制代码

我们开发者如果需要使用ServletContextInitializer来初始化ServletContext的话，也可以编写一个实现类，然后将其注册到spring容器即可。
另外，SpringBoot还会自动装配DispatcherServletAutoConfiguration类，这个类会创建DispatcherServlet和DispatcherServletRegistrationBean。DispatcherServlet是SpringWebMvc的最核心组件，DispatcherServletRegistrationBean实现了ServletContextInitializer接口，可以将DispatcherServlet注册到ServletContext。以TomcatServletWebServerFactory为例，这个类会通过TomcatStarter来调用所有的ServletContextInitializer，TomcatStarter实现了ServletContainerInitializer接口，Tomcat的ServletContext在启动阶段会调用ServletContainerInitializer的onStartup方法来初始化Servlet容器。
SpringBoot启动流程

• 初始化environment应用配置参数：servletConfigInitParams, servletContextInitParams, systemProperties, systemEnvironment及配置文件等
  
• 创建ApplicationContext对象，SpringBoot应用默认使用的是AnnotationConfigServletWebServerApplicationContext类
  
• prepareContext阶段：触发一些事件，将启动类注册到Spring容器
  
• refresh阶段：扫描应用组件，自动装配
  
• onRefresh阶段：创建并初始化WebServer
  
• 调用ApplicationRunner和CommandLineRunner
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！