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>() {@Overridepublic 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>() {@Overridepublic 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方法的执行不同阶段中发布对应的事件：

1. 得到事件发布器后，会发布listeners.starting(); 事件，代表spring boot 开始启动。
2. prepareEnvironment(listeners, applicationArguments);方法执行时，会发布listeners.environmentPrepared(environment); 事件，代表环境信息准备完成
3. prepareContext(context, environment, listeners, applicationArguments, printedBanner); 方法执行时，会发布listeners.contextPrepared(context);事件，代表spring容器创建，但未调用初始化器。listeners.contextLoaded(context);事件，代表所有bean definition加载完毕。（然后会调用context.refresh();方法）
4. 在调用context.refresh();方法后，会发布listeners.started(context);事件
5. 如果在这个过程中发生了异常，会发布listeners.failed(context, exception); 事件
6. 最后会发布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>() {@Overridepublic 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）。这个钩子用于在应用程序关闭时执行一些清理操作或释放资源。

---

2.12、执行初始化方法

        run方法中的callRunners 用于执行初始化方法中编写的逻辑：

        “2.2、封装args参数”的作用就体现在此：

        ApplicationRunner需要将args参数包装成为ApplicationArguments类型：

        虽然无论是ApplicationRunner还是CommandLineRunner，调用callRunner() 方法时传递的args参数类型都是ApplicationArguments。但是不代表CommandLineRunner需要ApplicationArguments参数类型：

        会取出原本的String args 参数