SpringBoot启动过程源码解析--万字解析

最新推荐文章于 2024-10-11 02:01:21 发布
最新推荐文章于 2024-10-11 02:01:21 发布
阅读量435 收藏 1
点赞数 1
分类专栏： 学习计划 微服务 文章标签： spring boot servlet java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuejun_1996/article/details/128653833
版权

本篇文章将从Spring Boot的main函数入口，一步一步带领大家阅读spring boot的源代码，并且会详细解释spring boot各个类和方法上注释的含义，帮助阅读英文有困难的同学更好的理解spring boot的原理，话不多说，直接开始。

程序入口

通常在一个spring boot的应用中，会看到下面一段代码作为应用的入口。

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

那么这段代码究竟做了什么呢，让我们深入来分析它背后的原理。当我们点击run来查看源代码时，会看到下面这段代码，这段注释说明这是一个助手方法，可以通过指定一个primarySource的source源来启动，这个primarySource其实就是我们的启动类MyApplication。

/**
 * Static helper that can be used to run a {@link SpringApplication} from the
 * specified source using default settings.
 * @param primarySource the primary source to load
 * @param args the application arguments (usually passed from a Java main method)
 * @return the running {@link ApplicationContext}
 */
public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
   return run(new Class<?>[] { primarySource }, args);
}

接着，我们继续进入run方法，你会看到另外一个helper方法，这个helper方法首先初始化一个SpringApplication，然后再一次执行SpringApplication实例的run方法。

public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
   // 构造SpringApplication对象
   return new SpringApplication(primarySources).run(args);
}

1、构造SpringApplication对象

我们将一行一行逐步讲解初始化SpringApplication的逻辑

在这里插入图片描述

首先将启动类放入primarySources

// 将启动类放入primarySources
this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));

1、推测Web应用类型

  1. 如果项目依赖中存在org.springframework.web.reactive.DispatcherHandler，并且不存在org.springframework.web.servlet.DispatcherServlet，那么应用类型为WebApplicationType.REACTIVE
  2. 如果项目依赖中不存在org.springframework.web.reactive.DispatcherHandler，也不存在org.springframework.web.servlet.DispatcherServlet，那么应用类型为WebApplicationType.NONE
  3. 否则，应用类型为WebApplicationType.SERVLET
// 1. 推测web应用类型（NONE、REACTIVE、SERVLET）
this.webApplicationType = WebApplicationType.deduceFromClasspath();

进入deduceFromClasspath 方法：

static WebApplicationType deduceFromClasspath() {
   if (ClassUtils.isPresent(WEBFLUX_INDICATOR_CLASS, null) && !ClassUtils.isPresent(WEBMVC_INDICATOR_CLASS, null)
         && !ClassUtils.isPresent(JERSEY_INDICATOR_CLASS, null)) {
      return WebApplicationType.REACTIVE;
   }
   for (String className : SERVLET_INDICATOR_CLASSES) {
      if (!ClassUtils.isPresent(className, null)) {
         return WebApplicationType.NONE;
      }
   }
   return WebApplicationType.SERVLET;
}

2、获取BootstrapRegistryInitializer对象

  1. 从"META-INF/spring.factories"中读取key为BootstrapRegistryInitializer类型的扩展点，并实例化出对应扩展点对象
  2. BootstrapRegistryInitializer的作用是可以初始化BootstrapRegistry
  3. 上面的DefaultBootstrapContext对象就是一个BootstrapRegistry，可以用来注册一些对象，这些对象可以用在从SpringBoot启动到Spring容器初始化完成的过程中
  4. 我的理解：没有Spring容器之前就利用BootstrapRegistry来共享一些对象，有了Spring容器之后就利用Spring容器来共享一些对象
// 2. 从spring.factories中获取BootstrapRegistryInitializer对象
this.bootstrapRegistryInitializers = new ArrayList<>(
      getSpringFactoriesInstances(BootstrapRegistryInitializer.class));

进入getSpringFactoriesInstances 方法：

在这里插入图片描述

有人可能会问，BootstrapRegistryInitializer是干什么的呀，我们为什么要加载BootstrapRegistryInitializer呢，我们从Java Doc里就可以明白这个接口是通过Initialize的方法来加载BootstrapRegistry的。

/**
 * Callback interface that can be used to initialize a {@link BootstrapRegistry} before it
 * is used.
 *
 * @author Phillip Webb
 * @since 2.4.5
 * @see SpringApplication#addBootstrapRegistryInitializer(BootstrapRegistryInitializer)
 * @see BootstrapRegistry
 */
@FunctionalInterface
public interface BootstrapRegistryInitializer {

   /**
    * Initialize the given {@link BootstrapRegistry} with any required registrations.
    * @param registry the registry to initialize
    */
   void initialize(BootstrapRegistry registry);

}

可能又有人问，什么是 BootstrapRegistry，我们继续看Java Doc，继承这个注册接口的类会在ApplicationContext准备好之前可用，并且接口上有一个register的方法和一个addCloseListener

  • register: 以class为key来注册一些对象的实例来使用
  • addCloseListener: 在BootstrapContext关闭和ApplicationContext准备好之前调用该Listener

那么我们可以简单理解为这个BootstrapRegistry是为了让spring boot在 ApplicationContext准备好之前能有机会来注册一些类，并且通过触发ApplicationContext ready的事件来处理一些逻辑

3、获取ApplicationContextInitializer对象

  1. 从"META-INF/spring.factories"中读取key为ApplicationContextInitializer类型的扩展点，并实例化出对应扩展点对象
  2. 顾名思义，ApplicationContextInitializer是用来初始化Spring容器ApplicationContext对象的，比如可以利用ApplicationContextInitializer来向Spring容器中添加ApplicationListener
// 3. 从spring.factories中获取ApplicationContextInitializer对象
setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));

4、获取ApplicationListener对象

  1. 从"META-INF/spring.factories"中读取key为ApplicationListener类型的扩展点，并实例化出对应扩展点对象
  2. ApplicationListener是Spring中的监听器，并不是SpringBoot中的新概念，不多解释了
// 4. 从spring.factories中获取ApplicationListener对象
setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));

5、推测出Main类（main()方法所在的类）

  1. 没什么具体的作用，逻辑是根据当前线程的调用栈来判断main()方法在哪个类，哪个类就是Main类
// 5. 推测出Main类（main()方法所在的类）
this.mainApplicationClass = deduceMainApplicationClass();

2、启动SpringBoot：run(agrs)

现在开始拆解启动SpringApplication的过程。

/**
 * Run the Spring application, creating and refreshing a new
 * {@link ApplicationContext}.
 * @param args the application arguments (usually passed from a Java main method)
 * @return a running {@link ApplicationContext}
 */
public ConfigurableApplicationContext run(String... args) {
   long startTime = System.nanoTime();

   // 1、创建引导启动器，类似一个ApplicationContext，可以往里面添加一些对象
   DefaultBootstrapContext bootstrapContext = createBootstrapContext();

   ConfigurableApplicationContext context = null;
   configureHeadlessProperty();

   // 2、从spring.factories中获取SpringApplicationRunListener对象
   // 默认会拿到一个EventPublishingRunListener，它会启动过程的各个阶段发布对应的ApplicationEvent事件
   SpringApplicationRunListeners listeners = getRunListeners(args);

   // 3、发布ApplicationStartingEvent
   listeners.starting(bootstrapContext, this.mainApplicationClass);
   try {

      // 4、将run()的参数封装为DefaultApplicationArguments对象
      ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);

      // 5、准备Environment
      // 包括操作系统，JVM、ServletContext、properties、yaml等等配置
      // 会发布一个ApplicationEnvironmentPreparedEvent
      ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);

      // 默认spring.beaninfo.ignore=true，表示不需要jdk缓存beanInfo信息，Spring自己会缓存
      configureIgnoreBeanInfo(environment);

      Banner printedBanner = printBanner(environment);

      // 6、根据应用类型创建Spring容器
      context = createApplicationContext();
      context.setApplicationStartup(this.applicationStartup);

      // 7、利用ApplicationContextInitializer初始化Spring容器
      // 8、发布ApplicationContextInitializedEvent
      // 9、关闭DefaultBootstrapContext
      // 10、注册primarySources类，就是run方法存入进来的配置类
      // 11、发布ApplicationPreparedEvent事件
      prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);

      // 12、刷新Spring容器，会解析配置类、扫描、启动WebServer
      refreshContext(context);

      // 空方法
      afterRefresh(context, applicationArguments);

      // 启动时间
      Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
      if (this.logStartupInfo) {
         new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), timeTakenToStartup);
      }

      // 13、发布ApplicationStartedEvent事件，表示Spring容器已经启动
      listeners.started(context, timeTakenToStartup);

      // 14、从Spring容器中获取ApplicationRunner和CommandLineRunner，并执行其run()
      callRunners(context, applicationArguments);
   }
   catch (Throwable ex) {
      // 15、发布ApplicationFailedEvent事件
      handleRunFailure(context, ex, listeners);
      throw new IllegalStateException(ex);
   }

   try {
      Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);

      // 16、发布ApplicationReadyEvent事件，表示Spring容器已经准备好了
      listeners.ready(context, timeTakenToReady);
   }
   catch (Throwable ex) {
      handleRunFailure(context, ex, null);
      throw new IllegalStateException(ex);
   }
   return context;
}

1、创建DefaultBootstrapContext对象

  1. 首先创建一个default的bootstrapContext, 然后通过之前在初始化SpringApplication时找到的 bootstrapRegistryInitializers, 来初始化一个bootstrapContext
  2. BootstrapRegistryInitializer是一个接口，Spring Boot内并没有实现，需要用户根据自己的业务需求自己创建
private DefaultBootstrapContext createBootstrapContext() {
   // 创建一个default的bootstrapContext
   DefaultBootstrapContext bootstrapContext = new DefaultBootstrapContext();
   // 利用bootstrapRegistryInitializers初始化DefaultBootstrapContext
   this.bootstrapRegistryInitializers.forEach((initializer) -> initializer.initialize(bootstrapContext));
   return bootstrapContext;
}

2、设置java.awt.headless

根据系统变量java.awt.headless的值来设置Java headless mode，缺省值是true，因为大多数的Spring Boot项目都不是交互式应用，不需要显示设备，键盘或者鼠标等，所以默认值是headless mode

private void configureHeadlessProperty() {
   System.setProperty(SYSTEM_PROPERTY_JAVA_AWT_HEADLESS,
         System.getProperty(SYSTEM_PROPERTY_JAVA_AWT_HEADLESS, Boolean.toString(this.headless)));
}

3、获得SpringApplicationRunListener

通过getSpringFactoriesInstances方法获得并初始化所有在META/spring.factories里的SpringApplicationRunListener的子类。
默认会拿到一个EventPublishingRunListener，它会启动过程的各个阶段发布对应的ApplicationEvent事件

private SpringApplicationRunListeners getRunListeners(String[] args) {
   // 任何实现SpringApplicationRunListener.class的子类的构造函数必须有这2个类型的入参
   Class<?>[] types = new Class<?>[] { SpringApplication.class, String[].class };
   return new SpringApplicationRunListeners(logger,
         // 找到所有的SpringApplicationRunListener.class的子类并实例化
         getSpringFactoriesInstances(SpringApplicationRunListener.class, types, this, args),
         this.applicationStartup);
}

这里有个细节，就是这个继承SpringApplicationRunListener的子类必须有一个构造方法，它的入参是SpringApplication和String[].class，不然不会被实例化，而Spring的默认实现中只有一个子类EventPublishingRunListener，而这个默认的实现是用来广播在context准备好之前的事件的，例如ApplicationStartingEvent, ApplicationEnvironmentPreparedEvent 等

this.applicationStartup可以用来收集一些启动时的数据，这样一来如果我们的Spring Boot应用在启动时遇到了问题，就会比较容易定位问题。

4、发布ApplicationStartingEvent事件

void starting(ConfigurableBootstrapContext bootstrapContext, Class<?> mainApplicationClass) {
   doWithListeners("spring.boot.application.starting", (listener) -> listener.starting(bootstrapContext),
         (step) -> {
            if (mainApplicationClass != null) {
               step.tag("mainApplicationClass", mainApplicationClass.getName());
            }
         });
}

这里listener.starting(bootstrapContext)中的Listener就是上面提到的EventPublishingRunListener，下面的代码就是该类上的starting方法 ，可以很清楚的看到这里广播了一个ApplicationStartingEvent事件，广播事件使用了观察者的设计模式，这里就不展开了，有兴趣的读者可自行查看源码。

@Override
public void starting(ConfigurableBootstrapContext bootstrapContext) {
   // 这里的广播机制使用了典型的观察者模式
   this.initialMulticaster
         .multicastEvent(new ApplicationStartingEvent(bootstrapContext, this.application, this.args));
}

5、封装命令行参数ApplicationArguments

//  将run()的参数封装为DefaultApplicationArguments对象
ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);

6、创建Environment对象

Environment对象表示环境变量，该对象内部主要包含了:

  1. 当前操作系统的环境变量
  2. JVM的一些配置信息
  3. -D方式所配置的JVM环境变量

整个准备Environment的步骤相对复杂，现在对其逐一拆解
在这里插入图片描述

private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
      DefaultBootstrapContext bootstrapContext, ApplicationArguments applicationArguments) {
   // Create and configure the environment
   // 创建ApplicationServletEnvironment，里面添加了四个PropertySource
   // 1. StubPropertySource {name='servletConfigInitParams'}
   // 2. StubPropertySource {name='servletContextInitParams'}
   // 3. PropertiesPropertySource {name='systemProperties'}
   // 4. SystemEnvironmentPropertySource {name='systemEnvironment'}
   ConfigurableEnvironment environment = getOrCreateEnvironment();

   // 添加SimpleCommandLinePropertySource {name='commandLineArgs'}，放在首位
   configureEnvironment(environment, applicationArguments.getSourceArgs());

   // 把所有的PropertySources封装为一个ConfigurationPropertySourcesPropertySource
   // 然后添加到environment中，放在首位
   ConfigurationPropertySources.attach(environment);

   // 发布ApplicationEnvironmentPreparedEvent事件，表示环境已经准备好了
   // 默认EnvironmentPostProcessorApplicationListener会处理这个事件，会从spring.factories中拿出EnvironmentPostProcessor进一步处理Environment
   listeners.environmentPrepared(bootstrapContext, environment);

   // 最后，把defaultProperties移到最后
   DefaultPropertiesPropertySource.moveToEnd(environment);
   Assert.state(!environment.containsProperty("spring.main.environment-prefix"),
         "Environment prefix cannot be set via properties.");
   // 绑定environment
   bindToSpringApplication(environment);

   if (!this.isCustomEnvironment) {
       // 转换environment
      environment = convertEnvironment(environment);
   }
      // 重新添加ConfigurationPropertySource支持
   ConfigurationPropertySources.attach(environment);
   return environment;
}
1、根据webApplicationType创建变量对象

此时已经读取到了：java环境变量和系统环境变量

ConfigurableEnvironment environment = getOrCreateEnvironment();
2、配置环境变量

这里使用的缺省的configureEnvironment方法，只是简单的将我们Spring Boot的启动参数放进了Environment的propertySources中。因为这是一个preotected方法，所以我们也可以定制我们自己的configureEnvironment方法来达到完全控制Environment初始化的目的。

configureEnvironment(environment, applicationArguments.getSourceArgs());

/**
 * 这是个模板方法通过configurePropertySources和configureProfiles来完成配置
 * 我们也可以覆盖整个configureEnvironment方法来完全控制Environment的初始化
 * 或者只覆盖其中configurePropertySources和configureProfiles方法来部分定制化我们的配置
 */
protected void configureEnvironment(ConfigurableEnvironment environment, String[] args) {
   if (this.addConversionService) {
      // 添加一些类型转化器，比如把properties文件中的字符串转化成各种类型
      environment.setConversionService(new ApplicationConversionService());
   }
   // 添加SimpleCommandLinePropertySource {name='commandLineArgs'}，放在首位
   configurePropertySources(environment, args);

   // 空方法
   configureProfiles(environment, args);
}
3、将现有信息设置为@configurationProperties的数据源，并且放在第一位
/**
 * 添加一个ConfigurationPropertySource的支持，任何被ConfigurationPropertySource管理的Environment
 * 都将支持ConfigurationPropertyName的格式，并且能够动态的跟踪propertySource内变量的增加或减少
 */
public static void attach(Environment environment) {
   Assert.isInstanceOf(ConfigurableEnvironment.class, environment);
   MutablePropertySources sources = ((ConfigurableEnvironment) environment).getPropertySources();
   PropertySource<?> attached = getAttached(sources);
   if (attached == null || !isUsingSources(attached, sources)) {
      attached = new ConfigurationPropertySourcesPropertySource(ATTACHED_PROPERTY_SOURCE_NAME,
            new SpringConfigurationPropertySources(sources));
   }
   sources.remove(ATTACHED_PROPERTY_SOURCE_NAME);
   sources.addFirst(attached);
}

这里将Environment添加到一个ConfigurationPropertySource中去，这样做的好处有:

  • 可以支持ConfigurationPropertyName的属性名格式，比如属性名中出现server.hosts[0].name和 log[org.springboot].level这样的格式将能够解析
  • 可以跟踪增加或者删除propertySources
4、发布ApplicationEnvironmentPreparedEvent
listeners.environmentPrepared(bootstrapContext, environment);

void environmentPrepared(ConfigurableBootstrapContext bootstrapContext, ConfigurableEnvironment environment) {
   doWithListeners("spring.boot.application.environment-prepared",
         (listener) -> listener.environmentPrepared(bootstrapContext, environment));
}
5、绑定Environment

这里会重新创建一个Binder的实例，通过Binder将环境变量与SpringApplication绑定。

protected void bindToSpringApplication(ConfigurableEnvironment environment) {
   try {
      // 比如spring.main.allowBeanDefinitionOverriding=true
      Binder.get(environment).bind("spring.main", Bindable.ofInstance(this));
   }
   catch (Exception ex) {
      throw new IllegalStateException("Cannot bind to SpringApplication", ex);
   }
}
6、转换Environment

如果这不是一个定制的Environment，那么将对之前的Environment进行转换，生成StandardEnvironment。

if (!this.isCustomEnvironment) {
   environment = convertEnvironment(environment);
}

7、设置spring.beaninfo.ignore

private void configureIgnoreBeanInfo(ConfigurableEnvironment environment) {
   if (System.getProperty(CachedIntrospectionResults.IGNORE_BEANINFO_PROPERTY_NAME) == null) {
      Boolean ignore = environment.getProperty("spring.beaninfo.ignore", Boolean.class, Boolean.TRUE);
      System.setProperty(CachedIntrospectionResults.IGNORE_BEANINFO_PROPERTY_NAME, ignore.toString());
   }
}

此段较为简单，只是设置spring.beaninfo.ignore的值。缺省为true的意思就是使用spring内置的BeanInfo，而BeanInfo又是什么，简单来说就是用来将各种前段返回的数据直接映射到JavaBean上。

8、打印Banner

在这里插入图片描述
我们知道每个Spring Boot在启动的时候都会打印一个经典的图案，就是这里实现的，当然你可以换成自己的图案，支持文本格式或者图片格式，可以通过把banner.txt放到指定目录或者自定义自己的banner目录，这里就不展开了，有兴趣的读者可以自行研究。

9、根据应用类型创建Spring容器，实例化Spring上下文

默认是AnnotationConfigApplicationContext

context = createApplicationContext();

10、准备上下文

private void prepareContext(DefaultBootstrapContext bootstrapContext, ConfigurableApplicationContext context,
      ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
      ApplicationArguments applicationArguments, Banner printedBanner) {

   // 将前面生成的Environment设置到Spring容器中
   context.setEnvironment(environment);

   // 将设置在SpringApplication上的beanNameGenerator、resourceLoader设置到Spring容器中
   postProcessApplicationContext(context);

   // 利用ApplicationContextInitializer初始化Spring容器
   applyInitializers(context);

   // 发布ApplicationContextInitializedEvent事件，表示Spring容器初始化完成
   listeners.contextPrepared(context);

   // Spring容器初始化好了，就关闭DefaultBootstrapContext
   bootstrapContext.close(context);

   if (this.logStartupInfo) {
      logStartupInfo(context.getParent() == null);
      logStartupProfileInfo(context);
   }

   // 注册一些单例Bean
   // Add boot specific singleton beans
   ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
   beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
   if (printedBanner != null) {
      beanFactory.registerSingleton("springBootBanner", printedBanner);
   }

   // 设置allowCircularReferences和allowBeanDefinitionOverriding给Spring容器
   if (beanFactory instanceof AbstractAutowireCapableBeanFactory) {
      ((AbstractAutowireCapableBeanFactory) beanFactory).setAllowCircularReferences(this.allowCircularReferences);
      if (beanFactory instanceof DefaultListableBeanFactory) {
         ((DefaultListableBeanFactory) beanFactory)
               .setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
      }
   }

   if (this.lazyInitialization) {
      context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
   }

   // Load the sources
   // 拿到启动配置类（run方法传进来的类）
   Set<Object> sources = getAllSources();
   Assert.notEmpty(sources, "Sources must not be empty");

   // 将启动配置类解析为BeanDefinition注册到Spring容器中
   load(context, sources.toArray(new Object[0]));

   // 发布ApplicationPreparedEvent事件，表示Spring容器已经准备好
   listeners.contextLoaded(context);
}

整个准备上下文的步骤相对复杂，现在对其逐一拆解。

1、将当前的环境信息设置到context

context.setEnvironment(environment)

2、将设置在SpringApplication上的beanNameGenerator、resourceLoader设置到Spring容器中

postProcessApplicationContext(context);

3、调用ApplicationContextInitializer

applyInitializers(context)

4、发布ApplicationContextInitializedEvent
protected void applyInitializers(ConfigurableApplicationContext context) {
   for (ApplicationContextInitializer initializer : getInitializers()) {
      Class<?> requiredType = GenericTypeResolver.resolveTypeArgument(initializer.getClass(),
            ApplicationContextInitializer.class);
      Assert.isInstanceOf(requiredType, context, "Unable to call initializer.");
      initializer.initialize(context);
   }
}
5、关闭DefaultBootstrapContext

bootstrapContext.close(context);

6、打印启动信息和profile.active信息
if (this.logStartupInfo) {
   logStartupInfo(context.getParent() == null);
   logStartupProfileInfo(context);
}
7、将applicationArguments、printedBanner注册成bean
ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
if (printedBanner != null) {
   beanFactory.registerSingleton("springBootBanner", printedBanner);
}
8、设置不允许同名的bean
// 设置allowCircularReferences和allowBeanDefinitionOverriding给Spring容器
if (beanFactory instanceof AbstractAutowireCapableBeanFactory) {
   ((AbstractAutowireCapableBeanFactory) beanFactory).setAllowCircularReferences(this.allowCircularReferences);
   if (beanFactory instanceof DefaultListableBeanFactory) {
      ((DefaultListableBeanFactory) beanFactory)
            .setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
   }
}
9、设置是否懒加载bean
if (this.lazyInitialization) {
   context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
}
10、根据启动类加载所有的bean

这是容器加载非常关键的一步， 因为要根据启动类加载所有bean , 在这里启动类就相当于配置文件xml ,如果你之前看过AnnotationConfigApplicationContext, 它也会读取配置类， 一个意思。

// 将启动配置类解析为BeanDefinition注册到Spring容器中
load(context, sources.toArray(new Object[0]));

protected void load(ApplicationContext context, Object[] sources) {
   if (logger.isDebugEnabled()) {
      logger.debug("Loading source " + StringUtils.arrayToCommaDelimitedString(sources));
   }
   BeanDefinitionLoader loader = createBeanDefinitionLoader(getBeanDefinitionRegistry(context), sources);
   if (this.beanNameGenerator != null) {
      loader.setBeanNameGenerator(this.beanNameGenerator);
   }
   if (this.resourceLoader != null) {
      loader.setResourceLoader(this.resourceLoader);
   }
   if (this.environment != null) {
      loader.setEnvironment(this.environment);
   }
   loader.load();
}

11、刷新容器–加载ioc容器

afterRefresh(context, applicationArguments);

在这里插入图片描述

12、afterRefresh --待扩展

afterRefresh(context, applicationArguments);

13、触发SpringApplicationRunListener的started()

listeners.started(context);

发布ApplicationStartedEvent事件和AvailabilityChangeEvent事件，AvailabilityChangeEvent事件表示状态变更状态，变更后的状态为LivenessState.CORRECT。
LivenessState枚举有两个值：

    1. CORRECT：表示当前应用正常运行中
    1. BROKEN：表示当前应用还在运行，但是内部出现问题，暂时还没发现哪里用到了

14、调用ApplicationRunner和CommandLineRunner

  1. 获取Spring容器中的ApplicationRunner类型的Bean
  2. 获取Spring容器中的CommandLineRunner类型的Bean
  3. 执行它们的run()

15、触发SpringApplicationRunListener的ready()

发布ApplicationReadyEvent事件和AvailabilityChangeEvent事件，AvailabilityChangeEvent事件表示状态变更状态，变更后的状态为ReadinessState.ACCEPTING_TRAFFIC

ReadinessState枚举有两个值：

  1. ACCEPTING_TRAFFIC：表示当前应用准备接收请求
  2. REFUSING_TRAFFIC：表示当前应用拒绝接收请求，比如Tomcat关闭时，就会发布AvailabilityChangeEvent事件，并且状态为REFUSING_TRAFFIC

16、上述过程抛异常了就触发SpringApplicationRunListener的failed()

发布ApplicationFailedEvent事件

3、配置文件解析

流程图

4、SpringBoot完整的配置优先级

官 网

优先级由高到低：

  1. Default properties (specified by setting SpringApplication.setDefaultProperties).
  2. @PropertySource
  4. annotations on your @Configuration classes. Please note that such property sources are not added to the Environment until the application context is being refreshed. This is too late to configure certain properties such as logging.* and spring.main.* which are read before refresh begins.
  5. Config data (such as application.properties files).
  6. A RandomValuePropertySource that has properties only in random.*.
  7. OS environment variables.
  8. Java System properties (System.getProperties()).
  9. JNDI attributes from java:comp/env. 不管它
  10. ServletContext init parameters.
  11. ServletConfig init parameters.
  12. Properties from SPRING_APPLICATION_JSON (inline JSON embedded in an environment variable or system property).
  13. Command line arguments.
  14. properties attribute on your tests. Available on @SpringBootTest and the test annotations for testing a particular slice of your application.
  15. @TestPropertySource annotations on your tests.
  16. Devtools global settings properties in the $HOME/.config/spring-boot directory when devtools is active.

5、SpringBoot启动流程–思维导图版

总 结

小军的编程之旅
关注
专栏目录
[Spring Boot] 1. Spring Boot启动过程源码分析
不忘初心，好好沉淀
08-05 2万+
关于Spring Boot，已经有很多介绍其如何使用的文章了，本文从源代码(基于Spring-boot 1.5.6)的角度来看看Spring Boot的启动过程到底是怎么样的，为何以往纷繁复杂的配置到如今可以这么简便。1. 入口类package com.example.demo;import org.springframework.boot.SpringApplication; import org
springboot源码解析（一）
qq_34548229的博客
01-03 569
springboot源码解析（一） 1、springboot的入口程序 @SpringBootApplication public class StartupApplication { public static void main(String[] args) { SpringApplication.run(StartupApplication.class, args)...
Spring源码：SpringBoot启动流程分析
最新发布
qq_42449963的博客
10-11 360
通过百度网盘分享的文件：链接：https://pan.baidu.com/s/1fnt5fWSBLY7UfFPoZFyZpQ?pwd=gyg1 提取码： 按着按键点击方法：继续按着按键点击方法：继续按着按键点击构造方法：继续按着按键点击构造方法：我们逐步来分析SpringApplication构造方法中具体在什么事情：：resourceLoader是null，所以赋值也是null：将主启动类放到集合中，后续会使用到，知道有这么回事就行，看到时再提一下：获取当前的web环境，即使用还是，我们使用环境 ：往中放
SpringBoot一站式启动流程源码分析
Realize My Dream
06-06 206
&#13; &#13; 一、前言&#13; 　　由上篇文章我们得知，SpringBoot启动时，就是有很简单的一行代码。那我们可以很清楚的看到这行代码的主角便是SpringApplication了，本文我们就来聊一聊这货，来探寻SpringBoot的一站式启动流程。&#13; ​　　其实SpringApplication 是将一个典型的Spring应用的启动流程”模板化”了，...
SpringBoot启动流程源码解析
qq_39839075的博客
02-06 603
SpringBoot启动流程
SpringBoot启动过程源码解析
阿涛在Coding
01-07 300
SpringBoot 的启动流程就要从主启动类中的 run() 方法来看：启动过程的流程图：SpringBoot启动源码流程| ProcessOn免费在线作图,在线流程图,在线思维导图 1）如果项目依赖中存在org.springframework.web.reactive.DispatcherHandler，并且不存在 org.springframework.web.servlet.DispatcherServlet，那么应用类型为WebApplicationType.REACTIVE。2）如果项目依赖
SpringBoot源码分析(2)--SpringBoot启动源码(万字图文源码debug讲解springboot启动原理)
weixin_49114503的博客
07-04 1212
、SpringApplication实例化及run()方法 2.1、SpringApplication实例化 2.1.1、 web应用判断 2.1.2、设置初始化器 2.1.3、设置监听器 2.1.4、判断主应用入口类 2.2、run()方法 2.2.1、获取监听器集合getRunListeners(args) 2.2.1.1、开启监听器 2.2.2、准备Spring环境 prepareEnvironment() 2.2.3、打印banner图 2.2.4、创建Spring应用上下文createApplic
基于SpringBoot的影像注册系统04 sa-token使用（源码解析 + 万字）
2401_83915900的博客
04-20 1027
蚂蚁面试比较重视基础，所以Java那些基本功一定要扎实。蚂蚁的工作环境还是挺赞的，因为我面的是稳定性保障部门，还有许多单独的小组，什么三年1班，很有青春的感觉。面试官基本水平都比较高，基本都P7以上，除了基础还问了不少架构设计方面的问题，收获还是挺大的。经历这次面试我还通过一些渠道发现了需要大厂真实面试主要有：蚂蚁金服、拼多多、阿里云、百度、唯品会、携程、丰巢科技、乐信、软通动力、OPPO、银盛支付、中国平安等初，中级，高级Java面试题集合，附带超详细答案，希望能帮助到大家。
基于SpringBoot的影像注册系统04 sa-token使用（源码解析 + 万字
m0_67614284的博客
05-03 1790
逻辑：查询username存不存在，再查询密码是否正确，只要没有抛异常就调用sa-token的login方法。 StpUtil.login(userReal.getId()); login方法传入我们user的id，比如： 把int类型的数值传进去了。 步骤 4 sa-token登录认证 ================= [核心思想](() 所谓登录认证，说白了就是限制某些API接口必须登录后才能访问（例：查询我的账号资料） 那么如何判断一个会话是否登录？框架会在登录成功后给你做个标记，每次登录认证时校
校园闲置物品租售系统设计与实现——SpringBoot+Vue源码解析
资源摘要信息:"SpringBoot+Vue校园闲置物品租售系统源码及文档" 本项目是一个基于SpringBoot和Vue.js开发的校园闲置物品租售系统。系统分为三个角色：管理员、卖家和用户。各个角色拥有的功能如下： 管理员功能： ...
源码深度剖析SpringBoot启动流程中开启OpenFeign的入口（ImportBeanDefinitionRegistrar详解）
m0_67403013的博客
07-31 282
是spring对外提供的动态注册beanDefinition的接口，并且spring内部大多也用该接口动态注册beanDefinition。接口的Bean不会直接注册到IOC容器，它的执行时机比较早，发生在SpringBoot启动流程的注册BeanDefinition时；接口提供了registerBeanDefinitions(AnnotationMetadata,BeanDefinitionRegistry)供子类重写；）中注册。所谓的Spring临时容器是指）中。...
SpringBoot启动流程源码分析
SpringBoot应用最佳实践
05-29 841
大部分时候，SpringBoot应用主要通过在引导类调用SpringApplication的静态run方法启动，同时将引导类注册为配置源。比如下面是一个SpringMVC的Web应用，引导类是WebMVCBootstrap，和命令行参数args作为SpringApplication静态run方法的参数，用于构建SpringApplication对象和运行SpringBoot应用。 // 引导类添加@SpringBootApplication注解作为配置源，同时开启自动装配、缺省包路径扫描 @Spring
Spring boot启动流程源码解析
0xZzzz的博客
11-06 1659
阅读须知 版本：2.0.4 文章中使用/* */注释的方法会做深入分析 正文 @SpringBootApplication public class BootApplication { public static void main(String[] args) { SpringApplication.run(BootApplication.class, args); ...
Spring Boot启动源码解析
zql1455890112的博客
08-11 234
SrpingBoot启动原理
SpringBoot启动全流程源码解析
反作弊
02-10 628
SpringBoot启动过程流程图 源码解析 首先，我们先来看下SpringBoot项目的启动类 @SpringBootApplication 　　public class SpringDemoApplication { 　　　　public static void main(String[] args) { 　　　　SpringApplication.run(SpringDemoApplication.class, args); 　　　　} 　　} 一个是@SpringBootApplication，参
SpringBoot2 | SpringBoot启动流程源码分析（二）
热门推荐
程序员阿康
09-03 2万+
继续上一篇博客的启动流程分析。 在上一篇SpringBoot | SpringBoot2 | SpringBoot2启动流程源码分析（一）中我们提到springBoot启动流程大致有以下7点： 第一步：获取并启动监听器 第二步：构造容器环境 第三步：创建容器 第四步：实例化SpringBootExceptionReporter.class，用来支持报告关于启动的错误 第五步：准备容器...
springboot启动流程源码解析（带流程图）
meser88的博客
05-22 793
版权声明：本文为CSDN博主「wuweixianzheng」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。原文链接：https://blog.csdn.net/zkr1234562/article/details/128053698。
SpringBoot启动源码解读
weixin_42311088的博客
04-04 683
SpringBoot启动源码1 架构演变1.1 演变介绍1.2 区别2 SpringBoot的启动流程1.入口程序：2.创建SpringApplication对象2.1 如何加载的初始化器、监听器3 SpringApplication的run方法基本介绍4 创建EventPublishingRunListener并发布应用启动事件5 初始化应用参数6 根据运行监听器和应用参数来准备spring环境6.1 getOrCreateEnvironment6.2 configureEnvironment(envir
SpringBoot启动源码解析
MCN的博客
07-29 3366
一步一步分析SpringBoot启动源码（一） 一步一步分析SpringBoot启动源码（二） 一步一步分析SpringBoot启动源码（三）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小军的编程之旅

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值