spring boot启动流程

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

package com.example.demo;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {
    @GetMapping("/")
    public String hello(){
        return "hello";
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
    this.resourceLoader = resourceLoader;//null
    Assert.notNull(primarySources, "PrimarySources must not be null");//检查变量确保不为空

    //把传入的参数放入一个Set<Class<?>>,Set中只有一个值：DemoApplication.class
    this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));

    this.webApplicationType = WebApplicationType.deduceFromClasspath();//2.1.1
    
    this.bootstrapRegistryInitializers = getBootstrapRegistryInitializersFromSpringFactories();//2.1.2
    setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));//2.1.3
    setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));//2.1.4
    this.mainApplicationClass = deduceMainApplicationClass();//2.1.5
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

private List<BootstrapRegistryInitializer> getBootstrapRegistryInitializersFromSpringFactories() {
  //创建一个ArrayList用来保存结果
  ArrayList<BootstrapRegistryInitializer> initializers = new ArrayList<>();

  getSpringFactoriesInstances(Bootstrapper.class).stream()
      .map((bootstrapper) -> ((BootstrapRegistryInitializer) bootstrapper::initialize))
      .forEach(initializers::add);
  initializers.addAll(getSpringFactoriesInstances(BootstrapRegistryInitializer.class));
  return initializers;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

#spring-boot-2.4.5.jar/META-INF/spring.factories
org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.context.ConfigurationWarningsApplicationContextInitializer,\
org.springframework.boot.context.ContextIdApplicationContextInitializer,\
org.springframework.boot.context.config.DelegatingApplicationContextInitializer,\
org.springframework.boot.rsocket.context.RSocketPortInfoApplicationContextInitializer,\
org.springframework.boot.web.context.ServerPortInfoApplicationContextInitializer

#spring-boot-autoconfigure-2.4.5.jar/META-INF/spring.factories
org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,\
org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

public ConfigurableApplicationContext run(String... args) {
  StopWatch stopWatch = new StopWatch();//实例化一个计时器
  stopWatch.start();//启动计时器

  DefaultBootstrapContext bootstrapContext = createBootstrapContext();//2.2.1
  ConfigurableApplicationContext context = null;//初始化context
  configureHeadlessProperty();//2.2.2
  SpringApplicationRunListeners listeners = getRunListeners(args);//2.2.3
  listeners.starting(bootstrapContext, this.mainApplicationClass);//2.2.3
  try {
    ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);//2.2.4
    ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);//2.2.5
    configureIgnoreBeanInfo(environment); // 2.2.6
    Banner printedBanner = printBanner(environment); //获取banner
    context = createApplicationContext(); // 2.2.7
    context.setApplicationStartup(this.applicationStartup); // 2.2.8
    prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner); //2.2.9
    refreshContext(context); // 2.2.10
    afterRefresh(context, applicationArguments); // 示例中为空
    stopWatch.stop(); // 停止计时器
    // 在控制台打印计时器的启动时间信息
    if (this.logStartupInfo) {
      new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
    }

    // 通知对应的监听器，表明context已经启动,示例中ApplicationStartedEvent事件对应的监听器没有操作，只触发了AvailabilityChangeEvent事件，表明context正确运行，并在ApplicationAvailabilityBean的events属性中记录相应信息，状态：事件的AMP
    listeners.started(context); 
    callRunners(context, applicationArguments); // 示例中这一步为空。调用ApplicationRunner和CommandLineRunner类型的run方法
  }
  catch (Throwable ex) {
    handleRunFailure(context, ex, listeners);
    throw new IllegalStateException(ex);
  }

  try {
    listeners.running(context); //　通知对应的监听器，表明context已经在运行，跟前面的started类似，这里ApplicationReadyEvent事件对应的监听器没有操作，更新了context的状态ReadinessState.ACCEPTING_TRAFFIC
  }
  catch (Throwable ex) {
    handleRunFailure(context, ex, null);
    throw new IllegalStateException(ex);
  }
  return context; // 2.2.11
}

1
2
3
4
5

private DefaultBootstrapContext createBootstrapContext() {
  DefaultBootstrapContext bootstrapContext = new DefaultBootstrapContext();
  this.bootstrapRegistryInitializers.forEach((initializer) -> initializer.initialize(bootstrapContext));
  return bootstrapContext;
}

1
2
3
4

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

1
2
3
4
5

FROM openjdk:11.0.11-oracle
WORKDIR /
ADD demo-0.0.1-SNAPSHOT.jar demo.jar
EXPOSE 8080
CMD ["java", "-Djava.awt.headless=false", "-jar", "demo.jar"]

1
2
3
4
5
6

private SpringApplicationRunListeners getRunListeners(String[] args) {
  Class<?>[] types = new Class<?>[] { SpringApplication.class, String[].class };
  return new SpringApplicationRunListeners(logger,
      getSpringFactoriesInstances(SpringApplicationRunListener.class, types, this, args),
      this.applicationStartup);
}

1
2
3
4
5
6
7
8

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

1
2
3
4

public void starting(ConfigurableBootstrapContext bootstrapContext) {
  this.initialMulticaster
      .multicastEvent(new ApplicationStartingEvent(bootstrapContext, this.application, this.args));
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
    DefaultBootstrapContext bootstrapContext, ApplicationArguments applicationArguments) {
  // Create and configure the environment
  ConfigurableEnvironment environment = getOrCreateEnvironment();
  configureEnvironment(environment, applicationArguments.getSourceArgs());
  ConfigurationPropertySources.attach(environment);

  listeners.environmentPrepared(bootstrapContext, environment);

  DefaultPropertiesPropertySource.moveToEnd(environment);//尝试移动defaultproperties,我们这里是null,所以无操作

  configureAdditionalProfiles(environment);//配置additionalProfiles，这里是空的集合，所以无操作

  bindToSpringApplication(environment);

  // 确保enviroment类型正确
  if (!this.isCustomEnvironment) {
    environment = new EnvironmentConverter(getClassLoader()).convertEnvironmentIfNecessary(environment,
        deduceEnvironmentClass());
  }

  //从上一次attach之后，enviroment中的propertysources已经发生变化，这里重新attach一次
  ConfigurationPropertySources.attach(environment);
  return environment;
}

1
2

sources.addFirst(new ConfigurationPropertySourcesPropertySource(ATTACHED_PROPERTY_SOURCE_NAME,
    new SpringConfigurationPropertySources(sources)));

1
2
3
4
5

@Override
public void setApplicationStartup(ApplicationStartup applicationStartup) {
  super.setApplicationStartup(applicationStartup);
  this.beanFactory.setApplicationStartup(applicationStartup);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

private void prepareContext(DefaultBootstrapContext bootstrapContext, ConfigurableApplicationContext context,ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
ApplicationArguments applicationArguments, Banner printedBanner) {
  context.setEnvironment(environment);
  postProcessApplicationContext(context);
  applyInitializers(context);
  listeners.contextPrepared(context); // 触发contextPrepared事件，让对应的监听器处理，这里有两个监听器符合条件，但无处理操作

  bootstrapContext.close(context); // 关闭bootstrapContext并触发相关事件，此处无对应监听器

  if (this.logStartupInfo) { // 是否打印启动信息
    logStartupInfo(context.getParent() == null); // 对应启动信息里的第一行
    logStartupProfileInfo(context); // // 对应启动信息里的第f二行
  }

  // Add boot specific singleton beans
  ConfigurableListableBeanFactory beanFactory = context.getBeanFactory(); // 获取beanfactory，值是`new DefaultListableBeanFactory()`
  beanFactory.registerSingleton("springApplicationArguments", applicationArguments); //注册applicationArguments

  if (printedBanner != null) { //如果application.properties里设置了spring.main.banner-mode=off，这里就跳过
    beanFactory.registerSingleton("springBootBanner", printedBanner); // 注册Banner
  }

  if (beanFactory instanceof DefaultListableBeanFactory) { // true

    // 给beanFactory设置是否允许BeanDefinitionOverriding,值是false
    ((DefaultListableBeanFactory) beanFactory)
        .setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
  }
  if (this.lazyInitialization) { // false
    context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
  }
  // Load the sources
  Set<Object> sources = getAllSources();
  Assert.notEmpty(sources, "Sources must not be empty"); // 检查sources不为空
  load(context, sources.toArray(new Object[0])); 
  listeners.contextLoaded(context); 
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

@Override
public void refresh() throws BeansException, IllegalStateException {
  synchronized (this.startupShutdownMonitor) {
    StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");

    // Prepare this context for refreshing.
    prepareRefresh(); // 初始化一些属性，判断this.earlyApplicationListeners是否有值，有的话把这些值传入this.applicationListeners（先清空），如果没有，则反过来，把this.applicationListeners的值传给this.earlyApplicationListeners

    // Tell the subclass to refresh the internal bean factory.
    ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); // 获取beanFactory,类型是DefaultListableBeanFactory，设置了serializableId=application

    // Prepare the bean factory for use in this context.
    prepareBeanFactory(beanFactory);

    try {

      // 添加一个WebApplicationContextServletContextAwareProcessor类型的postProcessor，及把ServletContextAware.class接口添加到ignoreDependencyInterface列表内
      // Allows post-processing of the bean factory in context subclasses.
      postProcessBeanFactory(beanFactory);

      // 启动一个步骤，步骤可以记录它开始到结束的数据，或者步骤耗时等，这里用处不大
      StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
      
      // Invoke factory processors registered as beans in the context.
      invokeBeanFactoryPostProcessors(beanFactory);

      // Register bean processors that intercept bean creation.
      registerBeanPostProcessors(beanFactory);
      // 结束步骤
      beanPostProcess.end();

      // Initialize message source for this context.
      // 初始化MessageSource,这里是空，并且步骤中会记录trace级别的log，如果在application.properties中开启的话，就可以看到
      initMessageSource();

      // Initialize event multicaster for this context.
      // 初始化applicationEventMulticaster属性，示例中用的是SimpleApplicationEventMulticaster类型
      initApplicationEventMulticaster();

      // Initialize other special beans in specific context subclasses.
      // 启动内嵌的tomcat容器，console输出相关5条INFO级别信息
      onRefresh();

      // Check for listener beans and register them.
      // 找到context中直接存在的listener以及bean中属于ApplicationListener类型的bean，注册到ApplicationEventMulticaster中(示例实现类是SimpleApplicationEventMulticaster)
      registerListeners();

      // Instantiate all remaining (non-lazy-init) singletons.
      finishBeanFactoryInitialization(beanFactory);

      // Last step: publish corresponding event.
      finishRefresh();
    }

    catch (BeansException ex) {
      if (logger.isWarnEnabled()) {
        logger.warn("Exception encountered during context initialization - " +
            "cancelling refresh attempt: " + ex);
      }

      // Destroy already created singletons to avoid dangling resources.
      destroyBeans();

      // Reset 'active' flag.
      cancelRefresh(ex);

      // Propagate exception to caller.
      throw ex;
    }

    finally {
      // Reset common introspection caches in Spring's core, since we
      // might not ever need metadata for singleton beans anymore...
      resetCommonCaches();
      contextRefresh.end();
    }
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
  // Tell the internal bean factory to use the context's class loader etc.
  beanFactory.setBeanClassLoader(getClassLoader());

  if (!shouldIgnoreSpel) { // 是否忽略SpEL(Spring Expression Language)，这里是不忽略，所以设置相应的解析器
    beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
  }

  // 添加一个propertyEditor的注册器，用来注册各种editor
  beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

  // Configure the bean factory with context callbacks.
  beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this)); // 添加一个beanPostProcessor，类型是ApplicationContextAwareProcessor，如果原先存在，则先删除再添加，添加在AbstractBeanFactory的beanPostProcessors属性上

  // 添加下面的几个类到ignoredDependencyInterfaces属性（从DefaultListableBeanFactory的父类AbstractAutowireCapableBeanFactory中继承），后面的一些操作会根据这个set属性中的接口来判断是否要过滤相应的属性（判断属性的setter方法是否源于实现相应的接口方法）
  // BeanFactoryAware.class是默认添加的
  beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
  beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
  beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
  beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
  beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
  beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
  beanFactory.ignoreDependencyInterface(ApplicationStartupAware.class);

  // 这一步类似于手动装配，第1个参数是类型，第2个参数是这个类型返回的实例，如果第2个参数实现了第1个参数的子接口，那么这个子接口也会被装配
  // BeanFactory interface not registered as resolvable type in a plain factory.
  // MessageSource registered (and found for autowiring) as a bean.
  beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
  beanFactory.registerResolvableDependency(ResourceLoader.class, this);
  beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
  beanFactory.registerResolvableDependency(ApplicationContext.class, this);

  // 添加一个针对ApplictionListener后处器
  // Register early post-processor for detecting inner beans as ApplicationListeners.
  beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

  // 跳过，loadTimeWeaver在JVM加载类之前通过transformer对类其进行处理，这里没有这个bean
  // Detect a LoadTimeWeaver and prepare for weaving, if found.
  if (!NativeDetector.inNativeImage() && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
    beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
    // Set a temporary ClassLoader for type matching.
    beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
  }

  // 确保下面几个类型的bean都注册了，如果没注册，就设置为当前context相关的实例
  // Register default environment beans.
  if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
    beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
  }
  if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
    beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
  }
  if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
    beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
  }
  if (!beanFactory.containsLocalBean(APPLICATION_STARTUP_BEAN_NAME)) {
    beanFactory.registerSingleton(APPLICATION_STARTUP_BEAN_NAME, getApplicationStartup());
  }
}