Spring底层入门（九）

boot的执行流程分为构造SpringApplication对象、调用run方法两部分

1、Spring Boot 执行流程-构造

通常我们会在SpringBoot的主启动类中写以下的代码：

参数一是当前类的字节码，参数二是main的args参数。

public class StartApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringApplication.class,args);
    }
}

在SpringApplication.run的内部，会做两件事：

创建SpringApplication对象：

以及调用SpringApplication对象的run方法：

在创建SpringApplication对象时，通常又会做下面几件事：

获取bean definition源
获取推断应用类型
ApplicationContext初始化器
监听器与事件
主类推断

1.1、获取bean definition源

this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));

将传入的 primarySources数组转换为 LinkedHashSet，并赋值给当前对象的 primarySources成员变量。这个集合用于存储应用程序的主要源，通常是启动类（例如，@SpringBootApplication注解标记的类）。

1.2、获取推断应用类型

this.webApplicationType = WebApplicationType.deduceFromClasspath();

通过deduceFromClasspath() 方法进行应用类型推论：

deduceFromClasspath() 是WebApplicationType的方法，WebApplicationType是一个枚举类：

简单说明一下这段代码：第一个if判断，如果是reactive.DispatcherHandler，并且不是servlet.DispatcherServlet和servlet.ServletContainer，就推断类型为REACTIVE并返回。

如果上面的条件不成立，也就是应用类型没有被推断为REACTIVE，就会循环成员变量的SERVLET_INDICATOR_CLASSES数组，该数组中有两个元素：

javax.servlet.Servlet
org.springframework.web.context.ConfigurableWebApplicationContext

如果任意一个元素不存在就推断类型为NONE并返回。

最后推论类型为SERVLET并返回

1.3、ApplicationContext初始化器

setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));

获取所有注册的 ApplicationContextInitializer实例，并将其设置为应用程序的初始化器。

通过SpringApplication实例的.addInitializers()方法注册初始化器

springApplication.addInitializers(new ApplicationContextInitializer<ConfigurableApplicationContext>() {
            @Override
            public void initialize(ConfigurableApplicationContext applicationContext) {
                if (applicationContext instanceof GenericApplicationContext){
                    ((GenericApplicationContext) applicationContext).registerBean("bean3",Bean3.class);
                }
            }
        });

1.4、监听器与事件

setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));

获取所有注册的 ApplicationListener实例，并将其设置为应用程序的监听器。

通过SpringApplication实例的.addListeners()方法注册监听器与事件

  springApplication.addListeners(new ApplicationListener<ApplicationEvent>() {
            @Override
            public void onApplicationEvent(ApplicationEvent event) {
                System.out.println("事件:"+event.getClass());
            }
        });

1.5、主类推断

this.mainApplicationClass = deduceMainApplicationClass();

调用deduceMainApplicationClass() 方法进行主类推论：

通过创建一个新的 RuntimeException对象来获取当前线程的堆栈轨迹（stack trace），即调用堆栈信息。
遍历堆栈信息，找到方法名为"main"的函数，并返回类的class对象
没有找到就抛出异常

2、Spring Boot 执行流程-run

2.1、事件发布器

在run方法中，首先会通过getRunListeners(args);得到 SpringApplicationRunListeners。

SpringApplicationRunListeners是一个事件发布器，会在run方法的执行不同阶段中发布对应的事件：

得到事件发布器后，会发布listeners.starting(); 事件，代表spring boot 开始启动。
prepareEnvironment(listeners, applicationArguments);方法执行时，会发布listeners.environmentPrepared(environment); 事件，代表环境信息准备完成
prepareContext(context, environment, listeners, applicationArguments, printedBanner); 方法执行时，会发布listeners.contextPrepared(context);事件，代表spring容器创建，但未调用初始化器。listeners.contextLoaded(context);事件，代表所有bean definition加载完毕。（然后会调用context.refresh();方法）
在调用context.refresh();方法后，会发布listeners.started(context);事件
如果在这个过程中发生了异常，会发布listeners.failed(context, exception); 事件
最后会发布listeners.running(context);事件，代表spring boot 启动完成

在第六点中，如果在发布listeners.running(context);事件的过程中出现异常，不会发布listeners.failed(context, exception); 事件：

我们也可以模拟一下上述过程：

事件发布器SpringApplicationRunListener是一个接口，其与子类的对应关系是放在spring.factories的配置文件中：

public class A34 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        SpringApplication springApplication = new SpringApplication(A34.class);
        springApplication.addListeners(new ApplicationListener<ApplicationEvent>() {
            @Override
            public void onApplicationEvent(ApplicationEvent event) {
                System.out.println(event.getClass());
            }
        });

        //演示事件发送器，获取事件发送器类名
        //事件发送器是一个接口，和子类的对应关系存放在spring.factories配置文件中
        List<String> factoryNames = SpringFactoriesLoader.loadFactoryNames(SpringApplicationRunListener.class, A34.class.getClassLoader());
        for (String name : factoryNames) {
            System.out.println(name);
            //创建事件发布器实现类
            Class<?> clazz = Class.forName(name);
            Constructor<?> constructor = clazz.getConstructor(SpringApplication.class, String[].class);
            EventPublishingRunListener publishingRunListener = (org.springframework.boot.context.event.EventPublishingRunListener) constructor.newInstance(springApplication, args);

            //模拟SpringApplication源码public ConfigurableApplicationContext run(String... args) 方法中的七个事件
            //spring boot 开始启动
            publishingRunListener.starting();
            //环境信息准备完成
            publishingRunListener.environmentPrepared(new StandardEnvironment());
            //在spring容器创建，并调用初始化器之前，发送此事件
            GenericApplicationContext context = new GenericApplicationContext();
            publishingRunListener.contextPrepared(context);
            //所有bean definition加载完毕
            publishingRunListener.contextLoaded(context);
            context.refresh();
            //spring 容器初始化完成 refresh方法调用完成，加载了所有后处理器，初始化所有单例
            publishingRunListener.started(context);
            //spring boot 启动完毕
            publishingRunListener.running(context);
            //过程中发生错误
            publishingRunListener.failed(context,new Exception("报错"));
        }
    }
}

2.2、封装args参数

ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);

用于将args参数进行封装，便于最后一步执行实现了ApplicationRunner接口的方法。（实现了CommandLineRunner或ApplicationRunner接口的方法会在boot启动时运行其中的逻辑）

2.3、创建环境对象

ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments); 用于创建环境对象：

getOrCreateEnvironment()方法用于根据不同的webApplication类型，去创建对应的环境对象。（webApplication类型是在构造SpringApplication时推论出的）

configureEnvironment(ConfigurableEnvironment environment, String[] args) 方法用于配置应用程序的环境：

environment.setConversionService(new ApplicationConversionService()); 会先添加转换器：

其中又有configureProfiles(environment, args);方法来配置环境的配置文件：

configurePropertySources(environment, args) 方法配置环境的属性源（重点：在这一步只加入命令行参数，没有加入application.properties）：

首先从环境中获取systemProperties和systemEnvironment

2.4、配置文件读取统一命名处理

prepareEnvironment中的 ConfigurationPropertySources.attach(standardEnvironment); 方法用于统一命名处理：

因为配置文件在读取的过程中可能会存在这样的问题：

我们定义了一个配置文件，每个键的格式都不一样：

当我们不做任何处理，在读取时键名统一使用"-"分隔时，只能读取到第一个的值，因为命名和文件中不匹配。ConfigurationPropertySources.attach() 方法可以解决这样的问题。

public class Step4 {
    public static void main(String[] args) throws IOException {
        StandardEnvironment standardEnvironment = new StandardEnvironment();
        standardEnvironment.getPropertySources().addLast(new ResourcePropertySource("step4",new ClassPathResource("step4.properties")));

        // run 源码中做了统一命名ConfigurationPropertySources.attach(environment);
        ConfigurationPropertySources.attach(standardEnvironment);
        //不做任何处理 只能读取第一个 因为命名和文件中的不匹配
        System.out.println(standardEnvironment.getProperty("user.first-name"));
        System.out.println(standardEnvironment.getProperty("user.middle-name"));
        System.out.println(standardEnvironment.getProperty("user.last-name"));
    }
}

在attach方法内部，最后会将configurationProperties加入environment的头部，以便优先被访问

2.5、EnvironmentPostProcessor功能扩展

EnvironmentPostProcessor相当于环境对象的后处理器，可以增加一些扩展。

prepareEnvironment 中的listeners.environmentPrepared(bootstrapContext, environment);

使用事件发布器去触发监听器，调用其中的后处理器方法：（监听器是在SpringApplication构造时加入的，但是需要等到环境对象创建后才应该触发其中的那些后处理器）

通过debug发现，在构造SpringApplication时已经加入了对于环境对象后处理器的监听器

关于后处理器的实现关系也是定义在spring.factories文件中的：

EnvironmentPostProcessorApplicationListener就是去读取EnvironmentPostProcessor中的后处理器

2.6、将环境中的键值和SpringApplication中的属性匹配

prepareEnvironment 中的bindToSpringApplication(environment); 用于将环境中的键值和SpringApplication中的属性匹配：

读取配置文件中以spring.main开头的键，并且与SpringApplication中的成员变量绑定：

上面配置文件中的键都是SpringApplication中的成员变量：

2.7、输出Banner图标

run()方法中的printBanner(environment); 用于在控制台或日志中输入图标：

2.8、创建容器

在环境准备完成并发布listeners.environmentPrepared(environment); 事件后，会创建容器：

createApplicationContext() 方法根据构造SpringApplication推断的不同的类型有不同的实现：

2.9、准备容器

prepareContext(context, environment, listeners, applicationArguments, printedBanner); 方法用于准备容器：

在准备容器时又会回调构造SpringApplication时编写的初始化器中的增强逻辑：

2.10、加载Bean定义

prepareContext方法中的load(context, sources.toArray(new Object[0]));

这段代码大致的意思是，加载应用程序的配置源，并根据需要设置相关的配置，然后执行加载操作。

根据不同的配置类型去分派对应的加载方法：

2.11、refresh

执行run中的refreshContext()方法：

调用refresh方法，加载配置、初始化所有单例、重新启动应用程序上下文。

在这之前还会判断，如果this.registerShutdownHook为true，那么会通过 shutdownHook.registerApplicationContext(context);方法为当前的应用程序上下文注册一个关机钩子（shutdown hook）。这个钩子用于在应用程序关闭时执行一些清理操作或释放资源。