SpringBoot启动原理分析

文章目录
  1. 1. 前言
  2. 2. 正文
    1. 2.1. 核心注解@SpringBootApplication
    2. 2.2. 自动配置核心类SpringFactoriesLoader
  3. 3. 整体启动流程
    1. 3.1. 初始化SpringApplication类
    2. 3.2. 执行核心run方法
      1. 3.2.1. run方法整体执行流程总结

前言

用了差不多两年的SpringBoot了,可以说对SpringBoot已经很熟了,但是仔细一想SpringBoot的启动流程,还是让自己有点懵逼,不得不说是自己工作和学习的失误,所以以此文对SpringBoot的启动流程略作记录。

此文的SpringBoot启动流程分析是基于SpringBoot 1.x的,SpringBoot 2.x的启动流程与1.x的略有不同,后续再进行补充分析。

正文

核心注解@SpringBootApplication

每个SpringBoot应用,都有一个入口类,标注@SpringBootApplication注解。

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

点开@SpringBootApplication的源码,可以看到这个注解其实包含了@SpringBootConfiguration,@EnableAutoConfiguration,@ComponentScan三个注解。

下面对这三个注解简单解释解释。

  • @SpringBootConfiguration

    对于这个注解不做解释,将这个注解点进去,发现还有@Configuration注解,对于@Configuration注解,用过Spring或SpringBoot的基本上都不陌生,标注了@Configuration的类相当于Spring中的配置XML,不过SpringBoot社区推荐使用JavaConfig,所以@Configuration就构建出了一个基础JavaConfig的Ioc容器。

  • @EnableAutoConfiguration

    Spring中有很多Enable*的注解,表示开启某项东西,如@EnableSchuduling。所以看这个注解的名字就知道是开启自动配置。这是一个复合注解,其中最主要的还是@Import,借助于EnableAutoConfigurationImportSelector,将所有符合自动配置条件的Bean加载到Ioc容器里。

    SpringBoot加载自动配置的方式有两种(目前我知道的):

    • 在classpath下新建META-INF/spring.factories文件,将标注了@Configuration的类的全路径配置到此文件中,如:

      1
      2
      3
      org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
      com.quartz.config.QuartzBeanConfiguration,\
      com.quartz.config.QuartzAutoConfiguration

      在启动时,通过SpringFactoriesLoader工具类,将所有META-INF目录下的spring.factories文件中的配置类加载到Ioc容器里。

    • 使用@Import,将配置类加载到Ioc容器里。

      1
      2
      3
      4
      5
      6
      @Target(ElementType.TYPE)
      @Retention(RetentionPolicy.RUNTIME)
      @Documented
      @Import({QuartzAutoConfiguration.class})
      public @interface EnableQuartz {
      }

      使用@Import导入的类必须满足以下任意一个要求:

      1. 导入的类使用@Configuration进行标注
      2. 导入的类中至少有一个使用@Bean标准的方法
      3. 导入的类实现了ImportSelector接口
      4. 导入的类实现了ImportBeanDefinitionRegistrar接口
  • @ComponentScan

    看到这个注解,可以回想一下以前使用SpringMVC时,xml配置文件里的一个标签

    1
    <context:component-scan base-package="" />

    不过这个注解一般不需要手动指定扫描的包路径,它默认会从标注了@ComponentScan的类所在包往下查找,将标注了如@Component,@Service等Bean加载到Ioc容器里。

自动配置核心类SpringFactoriesLoader

上面在说@EnableAutoConfiguration的时候有说META-INF下的spring.factories文件,那么这个文件是怎么被spring加载到的呢,其实就是SpringFactoriesLoader类。

SpringFactoriesLoader是一个供Spring内部使用的通用工厂装载器,SpringFactoriesLoader里有两个方法,

1
2
3
4
// 加载工厂类并实例化
public static <T> List<T> loadFactories(Class<T> factoryClass, ClassLoader classLoader) {}
// 加载工厂类的类名
public static List<String> loadFactoryNames(Class<?> factoryClass, ClassLoader classLoader) {}

在这个SpringBoot应用启动过程中,SpringFactoriesLoader做了以下几件事:

  1. 加载所有META-INF/spring.factories中的Initializer
  2. 加载所有META-INF/spring.factories中的Listener
  3. 加载EnvironmentPostProcessor(允许在Spring应用构建之前定制环境配置)
  4. 接下来加载Properties和YAML的PropertySourceLoader(针对SpringBoot的两种配置文件的加载器)
  5. 各种异常情况的FailureAnalyzer(异常解释器)
  6. 加载SpringBoot内部实现的各种AutoConfiguration
  7. 模板引擎TemplateAvailabilityProvider(如Freemarker、Thymeleaf、Jsp、Velocity等)

总得来说,SpringFactoriesLoader和@EnableAutoConfiguration配合起来,整体功能就是查找spring.factories文件,加载自动配置类。

整体启动流程

在我们执行入口类的main方法之后,运行SpringApplication.run,后面new了一个SpringApplication对象,然后执行它的run方法。

1
2
3
public static ConfigurableApplicationContext run(Object[] sources, String[] args) {
return new SpringApplication(sources).run(args);
}

初始化SpringApplication类

创建一个SpringApplication对象时,会调用它自己的initialize方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
private void initialize(Object[] sources) {
if (sources != null && sources.length > 0) {
this.sources.addAll(Arrays.asList(sources));
}
// 根据标志类javax.servlet.Servlet,org.springframework.web.context.ConfigurableWebApplicationContext是否存在,判断是否是web环境
this.webEnvironment = deduceWebEnvironment();
// 通过SpringFactoriesLoader,获取到所有META-INF/spring.factories中的ApplicationContextInitializer,并实例化
setInitializers((Collection) getSpringFactoriesInstances(
ApplicationContextInitializer.class));
// 通过SpringFactoriesLoader,获取到所有META-INF/spring.factories中的ApplicationListener,并实例化
setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
// 获取执行当前main方法的类,也就是启动类
this.mainApplicationClass = deduceMainApplicationClass();
}

注 : 各方法内部执行逻辑就不做说明了,比较简单,需要的读者可自行点进源码查看

执行核心run方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
public ConfigurableApplicationContext run(String... args) {
// 启动任务执行的时间监听器
StopWatch stopWatch = new StopWatch();
stopWatch.start();

ConfigurableApplicationContext context = null;
FailureAnalyzers analyzers = null;
// 设置系统java.awt.headless属性,确定是否开启headless模式(默认开启headless模式)
configureHeadlessProperty();
// 通过SpringFactoriesLoader,获取到所有META-INF/spring.factories下的SpringApplicationRunListeners并实例化
SpringApplicationRunListeners listeners = getRunListeners(args);
// 开始广播启动
listeners.started();
try {
// 创建SpringBoot默认启动参数对象
ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
// 根据启动参数创建并配置Environment(所有有效的配置,如Profile),并遍历所有的listeners,广播启动环境已准备
ConfigurableEnvironment environment = prepareEnvironment(listeners,applicationArguments);
// 打印启动图案
Banner printedBanner = printBanner(environment);
// 根据标志类(上面有提到过),创建对应类型的ApplicationContext
context = createApplicationContext();
// 创建异常解析器(当启动失败时,由此解析器处理失败结果)
analyzers = new FailureAnalyzers(context);
// 准备Spring上下文环境
// 在这个方法中,主要完成了以下几件事:
// 1、设置SpringBoot的环境配置(Environment)
// 2、注册Spring Bean名称的序列化器BeanNameGenerator,并设置资源加载器ResourceLoader
// 3、加载ApplicationContextInitializer初始化器,并进行初始化
// 4、统一将上面的Environment、BeanNameGenerator、ResourceLoader使用默认的Bean注册器进行注册
prepareContext(context, environment, listeners, applicationArguments,printedBanner);
// 注册一个关闭Spring容器的钩子
refreshContext(context);
// 获取当前所有ApplicationRunner和CommandLineRunner接口的实现类,执行其run方法
// ApplicationRunner和CommandLineRunner功能基本一样,在Spring容器启动完成时执行,唯一不同的是ApplicationRunner的run方法入参是ApplicationArguments,而CommandLineRunner是String数组
afterRefresh(context, applicationArguments);
// 通知所有listener,Spring容器启动完成
listeners.finished(context, null);
// 停止时间监听器
stopWatch.stop();
if (this.logStartupInfo) {
new StartupInfoLogger(this.mainApplicationClass)
.logStarted(getApplicationLog(), stopWatch);
}
return context;
} catch (Throwable ex) {
// 启动有异常时,调用异常解析器解析异常信息,根据异常级别,判断是否退出Spring容器
handleRunFailure(context, listeners, analyzers, ex);
throw new IllegalStateException(ex);
}
}

run方法整体执行流程总结

  • 获取所有的

如果文章对你有帮助,欢迎点击上方按钮打赏作者