springboot启动配置原理

2020-07-08 约 2457 字预计阅读 5 分钟次阅读

启动原理

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)

判断是否web应用
加载并保存所有ApplicationContextInitializer（META-INF/spring.factories），
加载并保存所有ApplicationListener
获取到主程序类

源码：

 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)

准备环境
- 执行ApplicationContextInitializer. initialize()
- 监听器SpringApplicationRunListener回调contextPrepared
- 加载主配置类定义信息
- 监听器SpringApplicationRunListener回调contextLoaded
刷新启动IOC容器；
- 扫描加载所有容器中的组件
- 包括从META-INF/spring.factories中获取的所有EnableAutoConfiguration组件
回调容器中所有的ApplicationRunner、CommandLineRunner的run方法
监听器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));
    }
}

运行结果：

自动配置

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

目录

springboot启动配置原理

启动原理

创建对象SpringApplication对象

运行run方法

事件监听机制演示

配置在META-INF/spring.factories

只需要放在IOC容器中

自动配置