Spring底层入门（九）

发布于：2024-05-10 ⋅ 阅读:(26) ⋅ 点赞:(0)

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的内部，会做两件事：

22f585c35f4a46ebafe90c5b4b7475d5.png

        创建SpringApplication对象：

522f66ff590f4edb95edb2c1ed367f2d.png

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

26c58a68365d45c6bc980068190f425d.png

        在创建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是一个枚举类：

6138abe362cf4ef8bb9c826bffeb8cbe.png

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

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

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

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

        最后推论类型为SERVLET并返回

2a71cef044264a848d37e31994170090.png

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对象
  • 没有找到就抛出异常

85874401b9f444c5bfb539ec77c0bfc4.png

2、Spring Boot 执行流程-run

2.1、事件发布器

           d910d04b858341c3afc678c13a7bb17a.png

        在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); 事件：

ef5f39e6433548668611e340c89488a5.png

260a99e12c0d49f19a260fa1ebdce8cf.png       

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

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

42315fec479047b9bc7f85d29aca3fbe.png

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启动时运行其中的逻辑）

9bf857101cd944539bf5d2d606b3a81f.png

2.3、创建环境对象

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

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

9e91e62e88024d188904a6b782449028.png

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

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

40534477df4745289a9c6994213a4d3e.png

f63d3f39dbfe483281db883c7926bed0.png

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

0b3c803e4d284264bd02b3e32a542e07.png

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

        首先从环境中获取systemProperties和systemEnvironment

dc1a19647ac64696a2f0506c23c4e158.png

3449b0ed3b7b4b5da20df4b42007ad70.png

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

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

8497702d5a0c4b5e860b898ae15ed00a.png

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

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

b720eb3e16574bdb921be32276e0af3c.png

        当我们不做任何处理，在读取时键名统一使用"-"分隔时，只能读取到第一个的值，因为命名和文件中不匹配。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的头部，以便优先被访问

b33e9df412fb463393ad611d00d93ebf.png

2.5、EnvironmentPostProcessor功能扩展

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

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

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

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

52a53295ade24a8d8154ef57b0998042.png

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

5e09a9ac00824e73af908f9dbbedfb21.png

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

453066fbdfa843d4bfc88b018d877fc0.png

c9e97b50c672451ab5e10409d4ba5701.png

75d5ff5f732f436580b4209551be4ab2.png

 

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

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

b72a60d4c0734658b1a47401c328577f.png

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

668d5b0a1d8f4840a48afec04482dd7f.png

4a42c00700e84074bee890781ffddcce.png

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

1f5e6f021ce84c8aa0ecefec7bba7eef.png

87f3dfc3caa34d6ea389ed9da07c90fc.png

2.7、输出Banner图标

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

96d6d075fcfa4252b369cd24ddd58a03.png

ea69ad024c624ec2aac5844c64f39e4f.png

2.8、创建容器

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

73e6687c718e421dae4e6c562e517ab4.png 
052d38d3bcb34ee8a01faac7d2d02884.png

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

98d326d1f8ae427792e6a51bb080e6b4.png

 

2.9、准备容器

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

a04c9dc70e894af58e22444cdf4185d4.png

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

f64f9744db2a4f03b5e586c2140a9313.png

c39e4ee7dcac4945aa4a2e84f139c9ef.png

2.10、加载Bean定义

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

0e0ea6d492074fd28726bb5348fb6600.png

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

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

c9cba4538722446a8bced548ab59e1f0.png

2.11、refresh

        执行run中的refreshContext()方法：

c4f2634a924c4c5c954fae84e10eb03b.png

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

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

3df94684cea24c13b993d61c0e75d857.png

2.12、执行初始化方法

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

06142929780743eda6f48148429ef2b2.png

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

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

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

        会取出原本的String args 参数

fb79392faa1b4806adfd38ddf229c765.png

 

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布