目录

springboot启动配置原理

启动原理

SpringApplication.run(主程序类)

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

在阅读源码时注意以下几个重要的事件回调机制

配置在META-INF/spring.factories

  • ApplicationContextInitializer
  • SpringApplicationRunListener

只需要放在ioc容器中

  • ApplicationRunner
  • CommandLineRunner

创建对象SpringApplication对象

new SpringApplication(primarySources)

  1. 判断是否web应用

  2. 加载并保存所有ApplicationContextInitializer(META-INF/spring.factories),

  3. 加载并保存所有ApplicationListener

  4. 获取到主程序类

源码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
   this.resourceLoader = resourceLoader;
   Assert.notNull(primarySources, "PrimarySources must not be null");
  //保存主配置类
   this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
  //判断当前是否一个web应用
   this.webApplicationType = WebApplicationType.deduceFromClasspath();
  //从类路径下找到META-INF/spring.factories配置的所有ApplicationContextInitializer;然后保存起来
   setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
  //从类路径下找到ETA-INF/spring.factories配置的所有ApplicationListener
   setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
  //从类路径下找到ETA-INF/spring.factories配置的所有ApplicationListener
   this.mainApplicationClass = deduceMainApplicationClass();
}

ApplicationContextInitializer:

20201025132348

ApplicationListener:

20201025132418

运行run方法

run(args)

  1. 准备环境

    • 执行ApplicationContextInitializer. initialize()
    • 监听器SpringApplicationRunListener回调contextPrepared
    • 加载主配置类定义信息
    • 监听器SpringApplicationRunListener回调contextLoaded
  2. 刷新启动IOC容器;

    • 扫描加载所有容器中的组件
    • 包括从META-INF/spring.factories中获取的所有EnableAutoConfiguration组件
  3. 回调容器中所有的ApplicationRunner、CommandLineRunner的run方法

  4. 监听器SpringApplicationRunListener回调finished

源码

 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
52
53
54
55
56
57
public ConfigurableApplicationContext run(String... args) {
   StopWatch stopWatch = new StopWatch();
   stopWatch.start();
   ConfigurableApplicationContext context = null;
   Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
   configureHeadlessProperty();
  //获取SpringApplicationRunListeners;从类路径下META-INF/spring.factories
   SpringApplicationRunListeners listeners = getRunListeners(args);
  //回调所有的获取SpringApplicationRunListener.starting()方法
   listeners.starting();
   try {
     //封装命令行参数
      ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
     //准备环境
     //创建环境完成后回调SpringApplicationRunListener.environmentPrepared();表示环境准备完成
      ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
      configureIgnoreBeanInfo(environment);
     // 打印springboot的banner
      Banner printedBanner = printBanner(environment);
     //创建ApplicationContext;决定创建web的ioc还是普通的ioc
      context = createApplicationContext();
      exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
            new Class[] { ConfigurableApplicationContext.class }, context);
     //准备上下文环境;将environment保存到ioc中;而且applyInitializers();
       //applyInitializers():回调之前保存的所有的ApplicationContextInitializer的initialize方法
       //回调所有的SpringApplicationRunListener的contextPrepared();
     //prepareContext运行完成以后回调所有的SpringApplicationRunListener的contextLoaded();
      prepareContext(context, environment, listeners, applicationArguments, printedBanner);
     // 刷新容器;ioc容器初始化(如果是web应用还会创建嵌入式的Tomcat);Spring注解版
      //扫描,创建,加载所有组件的地方;(配置类,组件,自动配置)
      refreshContext(context);
     //从ioc容器中获取所有的ApplicationRunner和CommandLineRunner进行回调
       //ApplicationRunner先回调,CommandLineRunner再回调
      afterRefresh(context, applicationArguments);
      stopWatch.stop();
      if (this.logStartupInfo) {
         new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
      }
     //所有的SpringApplicationRunListener回调started方法
      listeners.started(context);
      callRunners(context, applicationArguments);
   }
   catch (Throwable ex) {
      handleRunFailure(context, ex, exceptionReporters, listeners);
      throw new IllegalStateException(ex);
   }

   try {
      listeners.running(context);
   }
   catch (Throwable ex) {
      handleRunFailure(context, ex, exceptionReporters, null);
      throw new IllegalStateException(ex);
   }
  //整个SpringBoot应用启动完成以后返回启动后的ioc容器;
   return context;
}

事件监听机制演示

配置在META-INF/spring.factories

ApplicationContextInitializer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
package com.eh.springboot.listener;

import org.springframework.context.ApplicationContextInitializer;
import org.springframework.context.ConfigurableApplicationContext;

public class HelloApplicationContextInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        System.out.println("ApplicationContextInitializer...initialize..." + applicationContext);
    }
}

SpringApplicationRunListener

 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
package com.eh.springboot.listener;

import org.springframework.boot.SpringApplicationRunListener;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.core.env.ConfigurableEnvironment;

public class HelloSpringApplicationRunListener implements SpringApplicationRunListener {
    @Override
    public void starting() {
        System.out.println("SpringApplicationRunListener...starting...");
    }

    @Override
    public void environmentPrepared(ConfigurableEnvironment environment) {
        Object o = environment.getSystemProperties().get("os.name");
        System.out.println("SpringApplicationRunListener...environmentPrepared.." + o);
    }

    @Override
    public void contextPrepared(ConfigurableApplicationContext context) {
        System.out.println("SpringApplicationRunListener...contextPrepared...");
    }

    @Override
    public void contextLoaded(ConfigurableApplicationContext context) {
        System.out.println("SpringApplicationRunListener...contextLoaded...");
    }

    @Override
    public void started(ConfigurableApplicationContext context) {
        System.out.println("SpringApplicationRunListener...started...");
    }

    @Override
    public void running(ConfigurableApplicationContext context) {
        System.out.println("SpringApplicationRunListener...running...");
    }

    @Override
    public void failed(ConfigurableApplicationContext context, Throwable exception) {
        System.out.println("SpringApplicationRunListener...failed...");
    }
}

在类路径下(resources)新建META-INF文件夹,新建spring.factories文件,加入如下配置

1
2
3
4
5
6
7
# Initializers
org.springframework.context.ApplicationContextInitializer=\
com.eh.springboot.listener.HelloApplicationContextInitializer

# Application Listeners
org.springframework.boot.SpringApplicationRunListener=\
com.eh.springboot.listener.HelloSpringApplicationRunListener

只需要放在IOC容器中

ApplicationRunner

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
package com.eh.springboot.listener;

import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;

@Component
public class HelloApplicationRunner implements ApplicationRunner {
    @Override
    public void run(ApplicationArguments args) throws Exception {
        System.out.println("ApplicationRunner...run....");
    }
}

CommandLineRunner

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
package com.eh.springboot.listener;

import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

import java.util.Arrays;

@Component
public class HelloCommandLineRunner implements CommandLineRunner {
    @Override
    public void run(String... args) throws Exception {
        System.out.println("CommandLineRunner...run..." + Arrays.asList(args));
    }
}

运行结果:

http://img.cana.space/picStore/20201025135532.png

自动配置

  • Spring Boot启动扫描所有jar包的META-INF/spring.factories中配置 EnableAutoConfiguration组件
  • spring-boot-autoconfigure.jar\META-INF\spring.factories有启动时需要加载的 EnableAutoConfiguration组件配置
  • 配置文件中使用debug=true可以观看到当前启用的自动配置的信息
  • 自动配置会为容器中添加大量组件
  • Spring Boot在做任何功能都需要从容器中获取这个功能的组件
  • Spring Boot 总是遵循一个标准;容器中有我们自己配置的组件就用我们配置的,没有就用自动配 置默认注册进来的组件;