【源码分析】Springboot启动流程源码分析

1.简介

springboot版本：2.7.2

SpringApplication类是用来执行Spring框架启动的引导类。
有两种方式可以进行启动引导：

• 通过静态方法SpringApplication.run启动。
• 先创建SpringApplication实例，在调用的实例方法run进行启动。
  无论是以上哪种方式，最终都是通过创建SpringApplication实例，在调用run()启动。

    public static void main(String[] args) {
        SpringApplication.run(StateMachineApplication.class, args);
    }
1
2
3

2.源码总结分析

类：org.springframework.boot.SpringApplication

run(String… args) 方法分析

主要方法：下面

 public ConfigurableApplicationContext run(String... args) {
        long startTime = System.nanoTime();
        //初始化启动上下文
        DefaultBootstrapContext bootstrapContext = this.createBootstrapContext();
        ConfigurableApplicationContext context = null;
        //配置Headless模式:Headless模式是在环境缺少显示器等设备情况下的一种配置，和启动流程并无太多关系
        this.configureHeadlessProperty();
        //listeners 监听器可以用来监听SpringApplication启动过程中的各个阶段。
        //默认的监听器是EventPublishRunListener，用户也可以通过实现SpringApplicationRunListener接口，实现应用程序对SpringApplication启动过程的监听。
        SpringApplicationRunListeners listeners = this.getRunListeners(args);
        listeners.starting(bootstrapContext, this.mainApplicationClass);
        try {
        //准备环境，创建ConfigurableEnvironment对象
        //SpringApplication会创建Spring启动所需的环境，这个环境主要由ConfigurableEnviroment对象表示。首先，该对象确认了程序是否需要设置Web环境，其次，该对象还确定了程序所需要的参数和读取的配置文件等信息。此步骤会回调SpringApplicationRunListener的environmentPrepared()方法，通知监听器环境已经准备好。
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
            ConfigurableEnvironment environment = this.prepareEnvironment(listeners, bootstrapContext, applicationArguments);
            //决定是否跳过 BeanInfo 类的扫描
            this.configureIgnoreBeanInfo(environment);
            //只是会向控制台或是日志中输出Spring的Logo和版本信息
            Banner printedBanner = this.printBanner(environment);
            //创建应用程序上下文并加载Bean
            //扩展：在准备好环境之后，接下来要做的就是创建应用程序上下文ApplicationContext对象。ApplicationContext是Spring IoC的核心组件，它不仅是程序所需Bean的容器，还提供了国际化，事件发布等功能。
            //在创建应用程序上下文的时候，首先会根据之前配置决定上下文的具体类型（AnnotationConfigApplicationContext或是AnnotationConfigServletWebServerApplicationContext）。再通过反射实例化到对象。
            context = this.createApplicationContext();
            //为此应用程序上下文设置ApplicationStartup。
            context.setApplicationStartup(this.applicationStartup);
            //准备ApplicationContext
            //扩展：
            //虽然已经得到了ApplicationContext对象，但此时的对象还只是一个空白对象，需要准备和处理后，ApplicationContext才能被使用。
            //在准备过程中主要做了做了几件事：为ApplicationContext设置之前准备好的Environment对象。
			//通过对ApplicationContext后置处理或是BeanDefinitionLoader等方式往容器中添加一些初始的Bean。
			//应用默认的初始化器初始化应用程序上下文(责任链模式的应用，多个初始化器形成一个List，应用程序需要被每个初始化器应用一次，每个初始化器有自己的职责)。
			//准备过程中ApplicationRunListener发出两个消息，分别是contextPrepared和contextLoaded。
            this.prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
            //刷新上下文
            //扩展：(下面在去解析这个方法，比较复杂)
            //通过刷新应用程序上下文发现Bean并加载到容器中。refreshContext()会调用ApplicationContext.refresh()方法。
			//AbstractApplicationContext中定义了refresh()方法的基本框架(模板模式的应用)。
            this.refreshContext(context);
            //在Application完成刷新后，SpringApplication给子类留了afterRefresh()的方法作为回调。
            this.afterRefresh(context, applicationArguments);
            //启动完成后，stopWatch会记录下本次启动消费的时间。
            Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
            if (this.logStartupInfo) {
                (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), timeTakenToStartup);
            }
            //然后向ApplicationRunListener发布started事件,说明已经启动就绪
            listeners.started(context, timeTakenToStartup);
            //启动完成后，正式运行前，SpringApplication还会执行用户定义的ApplicationRunner和CommandLineRunner两个接口中定义的run()方法。
            this.callRunners(context, applicationArguments);
        } catch (Throwable var12) {
            this.handleRunFailure(context, var12, listeners);
            throw new IllegalStateException(var12);
        }

        try {
            //在执行完成后，向ApplicationRunListener发布runing的消息。至此，启动流程结束。
            Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);
            listeners.ready(context, timeTakenToReady);
            return context;
        } catch (Throwable var11) {
            this.handleRunFailure(context, var11, (SpringApplicationRunListeners)null);
            throw new IllegalStateException(var11);
        }
    }
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

this.refreshContext(context);分析

类：org\springframework\context\support\AbstractApplicationContext.java

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

			//准备刷新
			//准备刷新的阶段做了初始化和校验的工作。
			prepareRefresh();

			// 告诉子类刷新内部bean工厂
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// Prepare the bean factory for use in this context.（准备用于此上下文的bean工厂。）
			//准备BeanFactory  
			//扩展：
			//对BeanFactory的准备主要是：添加一些必要组件，比如类加载器，表达式解析器，属性编辑器注册表等。
			//以及一些后置处理器，比如ApplicationContextAwareProcessor(xxxAware的接口就是通过后置处理器在Bean创建的时候，通过后置处理器设置的)。此外还有一些特殊的Bean，environment,systemProperties和systemEnvirnoment。
			prepareBeanFactory(beanFactory);

			try {
				// (后置处理BeanFactory)Allows post-processing of the bean factory in context subclasses.
				//扩展：
				//对于非WebServlet环境的ApplicationContext而言这个方法是个空方法，但是Web环境下的ApplicationContext会通过这个方法定制一些后处理动作，比如添加WebApplicationContextServletAwareProcessor后置处理器，添加在web环境中可能使用的Scope（session和request）。
				postProcessBeanFactory(beanFactory);

				StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
				//(在上下文中调用注册为bean的工厂处理器。) Invoke factory processors registered as beans in the context.
				//其实就是实例化并调用BeanFactoryPostProcessor
				//扩展：（看标题有详细解释）
				//BeanFactoryPostProcessor是一种特殊的后置处理器，其操作的对象是针对BeanFactory。
				invokeBeanFactoryPostProcessors(beanFactory);

				// (注册Bean后置处理器)Register bean processors that intercept bean creation.\
				//扩展：
				//上一步是针对BeanFactory和BeanDefinitionRegistry的后置处理器，这一步从BeanFactory中获取针对普通Bean的后置处理器BeanFactoryPostProcessor放到专门的容器beanPostProcessors中。
				registerBeanPostProcessors(beanFactory);
				beanPostProcess.end();

				//(初始化MessageSource处理国际化相关内容) Initialize message source for this context.
				initMessageSource();

				//(初始化ApplicationEventMulticaster) Initialize event multicaster for this context.
				//扩展：
				//ApplicationEventMulticaster是ApplicationEvent广播器，可以通过这个对象向容器中添加移除Listener，也可以通过这个对象发布事件（观察者模式的应用）。
				initApplicationEventMulticaster();

				// (刷新应用程序)Initialize other special beans in specific context subclasses.
				// 扩展：
				//发现了所有的Bean，并且需要实例化的Bean也都被创建好了之后，Spring接下去要做的是创建ThemeSource（和主题相关的组件），以及创建Webserver如果存在。
				//此方法可以重写以添加特定于上下文的刷新工作的模板方法。在实例化单体之前，在初始化特殊bean时调用。
				onRefresh();

				//注册监听器 Check for listener beans and register them.
				//扩展：
				//这一步会将初始化得到的ApplicationListener方法和容器中获得ApplicationListener一起注册到ApplicationEventMulticaster中，并且如果存在需要早起发布的事件，则发布事件。
				registerListeners();

				// (初始化容器中的Bean)Instantiate all remaining (non-lazy-init) singletons.
				//扩展：
				//经过之前的步骤，现在容器中必要的组件都已经准备好了，并且所有需要容器管理的Bean也都已经被发现注册成BeanDefinition注册表中。
				//对于Scope是Singleton的Bean而言，此时已经具备了实例化Bean的条件，因此在这一步中，Spring会对所有Singleton且非lazy-init的Bean进行实例化。
				//主要做法就是获取容器中所有为singletion且非lazyInit的BeanDefinition，然后通过getBean创建出Bean的实例，保存在容器内部。
				finishBeanFactoryInitialization(beanFactory);

				//完成刷新 Last step: publish corresponding event.
				//主要是一些资源清理以及注册LifeCycleProcessor。LifeCycleProcessor可以用来在 Spring 生命周期的refresh和close时触发回调。并且发布Refresh的消息。ContextRefreshedEvent
				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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

BeanFactory 详解

BeanFactory是 Spring 框架中容器的底层实现，所有的 Bean 都存放在BeanFactory中，虽然ApplicationContext也实现了BeanFactory接口，但是在其内部还是将获取 Bean 的相关操作委托给内部的DefaultListableBeanFactory变量，只是ApplicationContext帮用户屏蔽了底层的操作，同时提供出一些更符合外部用户使用的接口。

BeanFactoryPostProcessor 详解

BeanFactoryPostProcessor 主要有三个后置处理器，分是:

1、SharedMetadataReaderFactoryContextInitializer$CachingMetadataReaderFactoryPostProcessor

2、ConfigurationWarningsApplicationContextInitializer$ConfigurationWarningsPostProcessor

3、ConfigFileApplicationListener$PropertySourceOrderingPostProcessor。
1
2
3
4
5

一般主要是这俩：

我们看名字也能发现类是怎么来的(外部类是xxxInitializer的就说明是初始化器设置的)。

其中第一个类和启动流程有关，因为它会向容器注册ConfigurationClassPostProcessor。

如果BeanFactoryPostProcessor同时又是BeanDefinitionRegistryPostProcessor，则先进行针对BeanDefinition注册表的后置处理，目的是为了发现Bean。

在最初的三个BeanFactoryProcessor后置处理完成后，会从容器中获取BeanDefinitionRegistryPostProcessor类型的后置处理器（这里主要会得到刚才加载的ConfigurationClassPostProcessor实例）。再调用这些BeanDefinitionRegistry的后置处理器，继续向发现并向容器中注册新的Bean。

这里主要是通过@Configuration注解作为入口发现Bean，如果发现的Bean中又存在新的@ConfigurationBean，则以此Bean为入口再进行发现，直到所有的Bean都被发现。

注意 Bean的发现过程只是向BeanDefinition注册表注册BeanDefinition的过程，并没有针对发现的Bean进行实例化（少部分需要用到的Bean会进行实例化，比如这部分会对BeanDefinitionRegistryPostProcessor类型的Bean实例化）。