• springboot run方法执行流程分析

    目录

    SpringBoot项⽬的main函数

    1.SpringApplication()

    推断应⽤类型deduceWebApplicationType()

     getSpringFactoriesInstances();

     2. run(args)

    2.1 获取并启动监听器 

     2.2 构造应⽤上下⽂环境

    prepareEnvironment()⽅法

    2.3 初始化应⽤上下⽂

    2.4 刷新应⽤上下⽂前的准备阶段

     2.5刷新应⽤上下⽂（IOC容器的初始化过程）

    SpringBoot项⽬的main函数

    1. @SpringBootApplication
    2. public class SpringBootMytestApplication{
    3.  
    4.     public static void main(String[] args) {
    5.         SpringApplication.run(SpringBootMytestApplication.class, args);
    6.  
    7.     }
    8. }

     点进run⽅法，primarySource就是引导类SpringBootMytestApplication

    1. public static ConfigurableApplicationContext run(Class primarySource, String... args) {
    2. //调用重载方法
    3.         return run(new Class[]{primarySource}, args);
    4.     }

    进入重载run方法

    1.     public static ConfigurableApplicationContext run(Class[] primarySources, String[] args) {
    2.         return (new SpringApplication(primarySources)).run(args);
    3.     }
    1.         SpringApplication()构造⽅法的作用加载各种配置信息，初始化各种配置对象
    2.         run(args)初始化容器

    1.SpringApplication()

    1. public SpringApplication(Class... primarySources) {
    2.         this((ResourceLoader)null, primarySources);
    3.     }
    4.  
    5. public SpringApplication(ResourceLoader resourceLoader, Class... primarySources) {
    6.         this.sources = new LinkedHashSet();
    7.         this.bannerMode = Mode.CONSOLE;
    8.         this.logStartupInfo = true;
    9.         this.addCommandLineProperties = true;
    10.         this.addConversionService = true;
    11.         this.headless = true;
    12.         this.registerShutdownHook = true;
    13.         this.additionalProfiles = Collections.emptySet();
    14.         this.isCustomEnvironment = false;
    15.         this.lazyInitialization = false;
    16.         this.applicationContextFactory = ApplicationContextFactory.DEFAULT;
    17.         this.applicationStartup = ApplicationStartup.DEFAULT;
    18.         //初始化资源加载器为null
    19.         this.resourceLoader = resourceLoader;
    20.         //断⾔，加载资源类不能为null
    21.         Assert.notNull(primarySources, "PrimarySources must not be null");
    22.         //初始化配置类的类名信息（格式转换）将primarySources数组转换为List，最后放到LinkedHashSet集合中
    23.         this.primarySources = new LinkedHashSet(Arrays.asList(primarySources));
    24.         //【1.1 推断应⽤类型，后⾯会根据类型初始化对应的环境。常⽤的⼀般都是servlet环境 】
    25.         this.webApplicationType = WebApplicationType.deduceFromClasspath();
    26. //【1.2 初始化classpath下 META-INF/spring.factories中已配置的BootstrapRegistryInitializer】
    27.         this.bootstrapRegistryInitializers = new ArrayList(this.getSpringFactoriesInstances(BootstrapRegistryInitializer.class));
    28. //【1.2 初始化classpath下META-INF/spring.factories中已配置的ApplicationContextInitializer】
    29.         this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));
    30. //【1.3 初始化classpath下所有已配置的ApplicationListener。ApplicationListener是spring的事件监听器，典型的观察者模式，实现ApplicationListener接⼝，通过ApplicationEvent类，可以实现对spring容器全⽣命周期的监听，当然也可以⾃定义监听事件】
    31.         this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
    32. //【1.4 根据调⽤栈，推断出 main ⽅法的类名 】
    33.         this.mainApplicationClass = this.deduceMainApplicationClass();
    34.     }

    推断应⽤类型deduceWebApplicationType()

    1. /**
    2.  * 判断 应⽤的类型
    3.  * NONE: 应⽤程序不是web应⽤，也不应该⽤web服务器去启动
    4.  * SERVLET: 应⽤程序应作为基于servlet的web应⽤程序运⾏，并应启动嵌⼊式servlet web（tomcat）服务器。
    5.  * REACTIVE: 应⽤程序应作为 reactive web应⽤程序运⾏，并应启动嵌⼊式reactive web服务器。
    6.  * @return
    7. */
    8. static WebApplicationType deduceFromClasspath() {
    9. //classpath下必须存在org.springframework.web.reactive.DispatcherHandler
    10.         if (ClassUtils.isPresent("org.springframework.web.reactive.DispatcherHandler", (ClassLoader)null) && !ClassUtils.isPresent("org.springframework.web.servlet.DispatcherServlet", (ClassLoader)null) && !ClassUtils.isPresent("org.glassfish.jersey.servlet.ServletContainer", (ClassLoader)null)) {
    11.             return REACTIVE;
    12.         } else {
    13.             String[] var0 = SERVLET_INDICATOR_CLASSES;
    14.             int var1 = var0.length;
    15.  
    16.             for(int var2 = 0; var2 < var1; ++var2) {
    17.                 String className = var0[var2];
    18.                 if (!ClassUtils.isPresent(className, (ClassLoader)null)) {
    19.                     return NONE;
    20.                 }
    21.             }
    22. /**classpath环境下存在javax.servlet.Servlet或者
    23. *org.springframework.web.context.ConfigurableWebApplicationContext
    24. */
    25.             return SERVLET;
    26.         }
    27.     }

            返回类型是WebApplicationType的枚举类型， WebApplicationType 有三个枚举，三 个枚举的解释如其中注释 　　

            具体的判断逻辑如下：

    • WebApplicationType.REACTIVE classpath下存在org.springframework.web.reactive.DispatcherHandler
    • WebApplicationType.SERVLET classpath下存在javax.servlet.Servlet或者 org.springframework.web.context.ConfigurableWebApplicationContext
    • WebApplicationType.NONE 不满⾜以上条件。

     getSpringFactoriesInstances();

            初始化classpath下 META-INF/spring.factories中已配置的类

    1.     private  Collection getSpringFactoriesInstances(Class type) {
    2.         return this.getSpringFactoriesInstances(type, new Class[0]);
    3.     }
    4.  
    5. /**
    6. * 通过指定的classloader 从META-INF/spring.factories获取指定的Spring的
    7. ⼯⼚实例
    8. * @param type
    9. * @param parameterTypes
    10. * @param args
    11. * @param 
    12. * @return
    13. */
    14.     private  Collection getSpringFactoriesInstances(Class type, Class[] parameterTypes, Object... args) {
    15.         ClassLoader classLoader = this.getClassLoader();
    16.  
    17. // Use names and ensure unique to protect against duplicates
    18.  //通过指定的classLoader从 META-INF/spring.factories 的资源⽂件中，
    19.  //读取 key 为 type.getName() 的 value
    20.         Set names = new LinkedHashSet(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
    21. //创建Spring⼯⼚实例
    22.         List instances = this.createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
    23. //对Spring⼯⼚实例排序（org.springframework.core.annotation.Order注解指定的顺序）
    24.         AnnotationAwareOrderComparator.sort(instances);
    25.         return instances;
    26.     }

             loadFactoryNames() 这个⽅法很重要，这个⽅法是spring-core中提供的从METAINF/spring.factories中获取指定的类（key）的同⼀⼊⼝⽅法

            在这⾥，获取的是key为 org.springframework.context.ApplicationContextInitializer 的类。

     2. run(args)

            SpringBoot 启动流程最重要的部分run⽅法，初始化容器

    1. //初始化容器，得到ApplicationContext对象
    2. public ConfigurableApplicationContext run(String... args) {
    3.         //记录程序开始运⾏时间
    4.         long startTime = System.nanoTime();
    5.         //将系统配置引导信息再次封装为上下文对象
    6.         DefaultBootstrapContext bootstrapContext = this.createBootstrapContext();
    7.         ConfigurableApplicationContext context = null;
    8.         //模拟输入输出信号，避免出现因缺少外设导致的信号传输失败，进而引发错误（模拟显示器、鼠标、键盘....），设置了一个java.awt.headless=true的信号，只是为了设备兼容
    9.         this.configureHeadlessProperty();
    10.         //1、获取当前注册的可运行的监听器
    11.         SpringApplicationRunListeners listeners = this.getRunListeners(args);
    12.         //监听器执行starting
    13.         listeners.starting(bootstrapContext, this.mainApplicationClass);
    14.  
    15.         try {
    16.             //获取参数
    17.             ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
    18.             //2、将前期读取的数据加载成了一个环境对象，用来描述信息，构造应⽤上下⽂环境
    19.             ConfigurableEnvironment environment = this.prepareEnvironment(listeners, bootstrapContext, applicationArguments);
    20.             //处理需要忽略的Bean
    21.             this.configureIgnoreBeanInfo(environment);
    22.             //打印banner
    23.             Banner printedBanner = this.printBanner(environment);
    24.             //3、初始化应⽤上下⽂，创建容器对象，根据前期配置的容器类型进行判定并创建
    25.             context = this.createApplicationContext();
    26.             //设置启动模式
    27.             context.setApplicationStartup(this.applicationStartup);
    28.             //4、刷新应⽤上下⽂（容器）前的准备阶段，对容器进行设置，参数来源于前期的设定
    29.             this.prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
    30.             //5、刷新应⽤上下⽂（容器）
    31.             this.refreshContext(context);
    32.             //刷新应⽤上下⽂（容器）后处理
    33.             this.afterRefresh(context, applicationArguments);
    34.             //记录程序运行时间
    35.             Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
    36.             //判断是否记录启动时间的日志
    37.             if (this.logStartupInfo) {
    38.                 //创建日志对象，输出日志信息，包含启动时间
    39.                 (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), timeTakenToStartup);
    40.             }
    41.             //监听器执行started
    42.             listeners.started(context, timeTakenToStartup);
    43.             this.callRunners(context, applicationArguments);
    44.         } catch (Throwable var12) {
    45.             this.handleRunFailure(context, var12, listeners);
    46.             throw new IllegalStateException(var12);
    47.         }
    48.  
    49.         try {
    50.             Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);
    51.             //监听器执行ready
    52.             listeners.ready(context, timeTakenToReady);
    53.             return context;
    54.         } catch (Throwable var11) {
    55.             this.handleRunFailure(context, var11, (SpringApplicationRunListeners)null);
    56.             throw new IllegalStateException(var11);
    57.         }
    58.     }

             在以上的代码中，启动过程中的重要步骤共分为六步

    1. 第⼀步：获取并启动监听器
    2. 第⼆步：构造应⽤上下⽂环境
    3. 第三步：初始化应⽤上下⽂
    4. 第四步：刷新应⽤上下⽂前的准备阶段
    5. 第五步：刷新应⽤上下⽂
    6. 第六步：刷新应⽤上下⽂后的扩展接⼝ 

    2.1 获取并启动监听器 

    获取监听器

    1. private SpringApplicationRunListeners getRunListeners(String[] args) {
    2.         Class[] types = new Class[]{SpringApplication.class, String[].class};
    3.         return new SpringApplicationRunListeners(logger, this.getSpringFactoriesInstances(SpringApplicationRunListener.class, types, this, args), this.applicationStartup);
    4.     }

     启动监听器

    1. void starting(ConfigurableBootstrapContext bootstrapContext, Class mainApplicationClass) {
    2.         this.doWithListeners("spring.boot.application.starting", (listener) -> {
    3.             listener.starting(bootstrapContext);
    4.         }, (step) -> {
    5.             if (mainApplicationClass != null) {
    6.                 step.tag("mainApplicationClass", mainApplicationClass.getName());
    7.             }
    8.  
    9.         });
    10.     }

     2.2 构造应⽤上下⽂环境

            应⽤上下⽂环境包括计算机的环境，Java环境，Spring的运⾏环 境，Spring项⽬的配置（在SpringBoot中就是那个熟悉的 application.properties/yml）等等。

    prepareEnvironment()⽅法

    1. private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners, DefaultBootstrapContext bootstrapContext, ApplicationArguments applicationArguments) {
    2.         //创建并配置相应的环境
    3.         ConfigurableEnvironment environment = this.getOrCreateEnvironment();
    4.         //根据⽤户配置，配置 environment系统环境
    5.         this.configureEnvironment((ConfigurableEnvironment)environment, applicationArguments.getSourceArgs());
    6.         ConfigurationPropertySources.attach((Environment)environment);
    7.         // 启动相应的监听器，其中⼀个重要的监听器ConfigFileApplicationListener 就是加载项⽬配置⽂件的监听器。
    8.         listeners.environmentPrepared(bootstrapContext, (ConfigurableEnvironment)environment);
    9.         DefaultPropertiesPropertySource.moveToEnd((ConfigurableEnvironment)environment);
    10.         Assert.state(!((ConfigurableEnvironment)environment).containsProperty("spring.main.environment-prefix"), "Environment prefix cannot be set via properties.");
    11.         this.bindToSpringApplication((ConfigurableEnvironment)environment);
    12.         if (!this.isCustomEnvironment) {
    13.             EnvironmentConverter environmentConverter = new EnvironmentConverter(this.getClassLoader());
    14.             environment = environmentConverter.convertEnvironmentIfNecessary((ConfigurableEnvironment)environment, this.deduceEnvironmentClass());
    15.         }
    16.  
    17.         ConfigurationPropertySources.attach((Environment)environment);
    18.         return (ConfigurableEnvironment)environment;
    19.     }

            ⽅法中主要完成的⼯作，⾸先是创建并按照相应的应⽤类型配 置相应的环境，然后根据⽤户的配置，配置系统环境，然后启动监听器，并加载系 统配置⽂件。

    2.3 初始化应⽤上下⽂

    2.4 刷新应⽤上下⽂前的准备阶段

    1. private void prepareContext(DefaultBootstrapContext bootstrapContext, ConfigurableApplicationContext context, ConfigurableEnvironment environment, SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {
    2.         //设置容器环境
    3.         context.setEnvironment(environment);
    4.         //执⾏容器后置处理
    5.         this.postProcessApplicationContext(context);
    6.         //执⾏容器中的 ApplicationContextInitializer 包括spring.factories和通过三种⽅式⾃定义的
    7.         this.applyInitializers(context);
    8.         //向各个监听器发送容器已经准备好的事件
    9.         listeners.contextPrepared(context);
    10.         bootstrapContext.close(context);
    11.         if (this.logStartupInfo) {
    12.             this.logStartupInfo(context.getParent() == null);
    13.             this.logStartupProfileInfo(context);
    14.         }
    15.  
    16.         ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
    17.         // Add boot specific singleton beans
    18.         //将main函数中的args参数封装成单例Bean，注册进容器
    19.         beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
    20.         //将 printedBanner 也封装成单例，注册进容器
    21.         if (printedBanner != null) {
    22.             beanFactory.registerSingleton("springBootBanner", printedBanner);
    23.         }
    24.  
    25.         if (beanFactory instanceof AbstractAutowireCapableBeanFactory) {
    26.             ((AbstractAutowireCapableBeanFactory)beanFactory).setAllowCircularReferences(this.allowCircularReferences);
    27.             if (beanFactory instanceof DefaultListableBeanFactory) {
    28.                 ((DefaultListableBeanFactory)beanFactory).setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
    29.             }
    30.         }
    31.  
    32.         if (this.lazyInitialization) {
    33.             context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
    34.         }
    35.  
    36.         context.addBeanFactoryPostProcessor(new SpringApplication.PropertySourceOrderingBeanFactoryPostProcessor(context));
    37.         Set sources = this.getAllSources();
    38.         Assert.notEmpty(sources, "Sources must not be empty");
    39.         //加载我们的启动类，将启动类注⼊容器
    40.         this.load(context, sources.toArray(new Object[0]));
    41.         //发布容器已加载事件
    42.         listeners.contextLoaded(context);
    43.     }
      44.  

       2.5刷新应⽤上下⽂（IOC容器的初始化过程）
       

       到IoC容器的初始化过程，主要分下⾯三步：
       

      1. BeanDefinition的Resource定位
      2. BeanDefinition的载⼊
      3. 向IoC容器注册BeanDefinition
       

      1. @Override
      2. public void refresh() throws BeansException,IllegalStateException {
      3.  synchronized (this.startupShutdownMonitor) {
      4.  // Prepare this context for refreshing.
      5.  //刷新上下⽂环境
      6.  prepareRefresh();
      7.  // Tell the subclass to refresh the internal bean
      8. factory.
      9.  //这⾥是在⼦类中启动 refreshBeanFactory() 的地⽅
      10. @Override
      11. public void refresh() throws BeansException,
      12. IllegalStateException {
      13.  synchronized (this.startupShutdownMonitor) {
      14.  // Prepare this context for refreshing.
      15.  //刷新上下⽂环境
      16.  prepareRefresh();
      17.  // Tell the subclass to refresh the internal bean
      18. factory.
      19.  //这⾥是在⼦类中启动 refreshBeanFactory() 的地⽅
      20. //发布容器事件，结束Refresh过程
      21.  finishRefresh();
      22.  } catch (BeansException ex) {
      23.  if (logger.isWarnEnabled()) {
      24.  logger.warn("Exception encountered during
      25. context initialization - " +
      26.  "cancelling refresh attempt: " + ex);
      27.  }
      28.  // Destroy already created singletons to avoid
      29. dangling resources.
      30.  destroyBeans();
      31.  // Reset 'active' flag.
      32.  cancelRefresh(ex);
      33.  // Propagate exception to caller.
      34.  throw ex;
      35.  } finally {
      36.  // Reset common introspection caches in Spring's
      37. core, since we
      38.  // might not ever need metadata for singleton
      39. beans anymore...
      40.  resetCommonCaches();
      41.  }
      42.  }
      43. }
       

      
                
                    
                

                
    44. 

                    相关阅读:
      
                    
芯探科技--泛自动驾驶激光雷达解决方案                            
      
2022年最新运维常用脚本学习                            
      
前端基础之《ECMAScript 6（9）—集合介绍与API》                            
      
数据可视化分析工具如何在国内弯道超车，迅速崛起？                            
      
CMMI和进化论                            
      
项目管理知识点                            
      
1.2 变量和数据类型（Python）                            
      
WangEditor在Vue前端的应用                            
      
Python 实现微信测试号情侣纪念消息推送（消息群发）                            
      
浅谈网络损伤仪HoloWAN的使用场景                            
      
                          
                
      45. 
                
    45. 
                    原文地址：https://blog.csdn.net/m0_62520968/article/details/127010595
                
      46.