SpringBoot之启动配置原理

旧城等待， 2022-05-18 01:39 257阅读 0赞

# 几个重要的事件回调机制 #

## 配置在META-INF/spring.factories ##

*  `ApplicationContextInitializer`
 *  `SpringApplicationRunListener`

## 只需要放在ioc容器中 ##

*  `ApplicationRunner`
 *  `CommandLineRunner`

--------------------

# 一、启动流程： #

以main方法为入口：

## 1、创建SpringApplication对象 ##

initialize(sources);
    
    private void initialize(Object[] sources) {
        //保存主配置类
        if (sources != null && sources.length > 0) {
            this.sources.addAll(Arrays.asList(sources));
        }
        //判断当前是否一个web应用
        this.webEnvironment = deduceWebEnvironment();
        //从类路径下找到META-INF/spring.factories配置的所有ApplicationContextInitializer；然后保存起来
        setInitializers((Collection) getSpringFactoriesInstances(
            ApplicationContextInitializer.class));
        //从类路径下找到ETA-INF/spring.factories配置的所有ApplicationListener
        setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
        //从多个配置类中找到有main方法的主配置类
        this.mainApplicationClass = deduceMainApplicationClass();
    }

![这里写图片描述][70]  
![这里写图片描述][70 1]

## 2、运行run方法 ##

public ConfigurableApplicationContext run(String... args) {
       StopWatch stopWatch = new StopWatch();
       stopWatch.start();
       ConfigurableApplicationContext context = null;
       FailureAnalyzers analyzers = null;
       configureHeadlessProperty();
    
       //获取SpringApplicationRunListeners；从类路径下META-INF/spring.factories
       SpringApplicationRunListeners listeners = getRunListeners(args);
       //回调所有的SpringApplicationRunListener.starting()方法
       listeners.starting();
       try {
          //封装命令行参数
          ApplicationArguments applicationArguments = new DefaultApplicationArguments(
                args);
          //准备环境
          ConfigurableEnvironment environment = prepareEnvironment(listeners,
                applicationArguments);
                //创建环境完成后回调SpringApplicationRunListener.environmentPrepared()；表示环境准备完成
    
          Banner printedBanner = printBanner(environment);
    
          //创建ApplicationContext；决定创建web的ioc还是普通的ioc
          context = createApplicationContext();
    
          analyzers = new FailureAnalyzers(context);
          //准备上下文环境;将environment保存到ioc中；而且applyInitializers()；
          //applyInitializers()：回调之前保存的所有的ApplicationContextInitializer的initialize方法
          //回调所有的SpringApplicationRunListener的contextPrepared()；
          prepareContext(context, environment, listeners, applicationArguments,
                printedBanner);
          //prepareContext运行完成以后回调所有的SpringApplicationRunListener的contextLoaded（）；
    
          //刷新容器；ioc容器初始化（如果是web应用还会创建嵌入式的Tomcat）；Spring注解版
          //扫描，创建，加载所有组件的地方；（配置类，组件，自动配置）
          refreshContext(context);
          //从ioc容器中获取所有的ApplicationRunner和CommandLineRunner进行回调
          //ApplicationRunner先回调，CommandLineRunner再回调
          afterRefresh(context, applicationArguments);
          //所有的SpringApplicationRunListener回调finished方法
          listeners.finished(context, null);
          stopWatch.stop();
          if (this.logStartupInfo) {
             new StartupInfoLogger(this.mainApplicationClass)
                   .logStarted(getApplicationLog(), stopWatch);
          }
           //整个SpringBoot应用启动完成以后返回启动的ioc容器；
          return context;
       }
       catch (Throwable ex) {
          handleRunFailure(context, listeners, analyzers, ex);
          throw new IllegalStateException(ex);
       }
    }

## 3、事件监听机制 ##

**`ApplicationContextInitializer`**

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

**`SpringApplicationRunListener`**

public class HelloSpringApplicationRunListener implements SpringApplicationRunListener { 
    
        //必须有的构造器
        public HelloSpringApplicationRunListener(SpringApplication application, String[] args){
    
        }
    
        @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 finished(ConfigurableApplicationContext context, Throwable exception) {
            System.out.println("SpringApplicationRunListener...finished...");
        }
    }

配置（META-INF/spring.factories）

org.springframework.context.ApplicationContextInitializer=\
    com.atguigu.springboot.listener.HelloApplicationContextInitializer
    
    org.springframework.boot.SpringApplicationRunListener=\
    com.atguigu.springboot.listener.HelloSpringApplicationRunListener

--------------------

**`ApplicationRunner`**

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

**`CommandLineRunner`**

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

只需要放在ioc容器中

--------------------

# 二、自动配置 #

• Spring Boot启动时扫描所有jar包的META-INF/spring.factories中配置的  
EnableAutoConfiguration组件

• spring-boot-autoconfigure.jar/META-INF/spring.factories配置了启动时需要加载的  
EnableAutoConfiguration组件

• 配置文件中使用debug=true可以观看到当前启用的自动配置的信息

• 自动配置会为容器中添加大量组件

• Spring Boot在做任何功能都需要从容器中获取这个功能的组件

• Spring Boot总是遵循一个标准：容器中有我们自己配置的组件就用我们配置的，没有就用自动配  
置默认注册进来的组件

[70]: /images/20220518/e2c5389c87d84f81b52d9bde8ebacd40.png
[70 1]: /images/20220518/76c4541c6e804128aa8ba36f9ccb2194.png