Spring Boot 框架整体启动流程详解

@SpringBootApplication
public class SpringBootDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringBootDemoApplication.class);
    }

}

	/**
	 * 静态方法，使用默认设置从指定的源启动SpringApplication
	 * @param primarySource 载入的指定源
	 * @param args 应用程序参数 (通过从Main方法传递)
	 * @return 正在运行的ApplicationContext
	 */
	public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
		return run(new Class<?>[] { primarySource }, args);
	}

	/**
	 * 静态方法，使用默认设置从指定的源启动SpringApplication
	 * @param primarySources 载入的制定源，数组形式
	 * @param args 应用程序参数 (通过从Main方法传递)，数组形式
	 * @return 正在运行的ApplicationContext
	 */
	public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
		return new SpringApplication(primarySources).run(args);
	}

public ConfigurableApplicationContext run(String... args) {
		//记录应用程序启动时间
		long startTime = System.nanoTime();
		//创建默认的引导上下文，循环调用BootstrapRegistryInitializer 中的 initialize
		DefaultBootstrapContext bootstrapContext = createBootstrapContext();
		ConfigurableApplicationContext context = null;
		//配置headless，默认为true，不使用图形界面
		configureHeadlessProperty();
		//获取SpringApplicationRunListeners实例，从META-INF/spring.factories 和 SpringApplicationHook 中获取
		SpringApplicationRunListeners listeners = getRunListeners(args);
		//启动SpringApplicationRunListeners实例，循环调用SpringApplicationRunListener实例的starting方法
		listeners.starting(bootstrapContext, this.mainApplicationClass);
		try {
			//创建默认的ApplicationArguments实例，用于保存应用程序接收到的命令行参数
			ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
			//准备环境，准备完毕后调用SpringApplicationRunListener实例的environmentPrepared方法
			ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
			//打印banner
			Banner printedBanner = printBanner(environment);
			//创建ApplicationContext,根据WebApplicationType类型
			context = createApplicationContext();
			//设置启动期间的度量记录类
			context.setApplicationStartup(this.applicationStartup);
			//准备应用程序上下文，这里会调用SpringApplicationRunListener实例的contextPrepared和contextLoaded方法
			prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
			//刷新应用程序上下文
			refreshContext(context);
			//刷新上下文后的操作，可以在子类实现
			afterRefresh(context, applicationArguments);
			//计算启动需要的时间
			Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
			//记录应用程序启动信息，默认是true
			if (this.logStartupInfo) {
				new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), timeTakenToStartup);
			}
			//调用SpringApplicationRunListener实例的started方法
			listeners.started(context, timeTakenToStartup);
			//执行ApplicationRunner和CommandLineRunner
			callRunners(context, applicationArguments);
		}
		catch (Throwable ex) {
			if (ex instanceof AbandonedRunException) {
				throw ex;
			}
			//处理应用程序启动失败的情况，处理退出码，发送ExitCodeEvent事件，调用SpringApplicationRunListener的failed方法，向用户发送失败报告（可以实现FailureAnalysisReporter自定义），优雅关闭应用程序上下文
			handleRunFailure(context, ex, listeners);
			throw new IllegalStateException(ex);
		}
		try {
			if (context.isRunning()) {
				//准备完成时间
				Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);
				//最后调用SpringApplicationRunListener的ready方法
				listeners.ready(context, timeTakenToReady);
			}
		}
		catch (Throwable ex) {
			if (ex instanceof AbandonedRunException) {
				throw ex;
			}
			handleRunFailure(context, ex, null);
			throw new IllegalStateException(ex);
		}
		//返回应用程序上下文
		return context;
	}

private DefaultBootstrapContext createBootstrapContext() {
//创建默认的引导上下文
		DefaultBootstrapContext bootstrapContext = new DefaultBootstrapContext();
		//循环调用initialize，可以在应用程序启动阶段进行初始化和注册，从而实现更具有个性化的应用程序配置和功能
	   this.bootstrapRegistryInitializers.forEach((initializer) -> initializer.initialize(bootstrapContext));
		return bootstrapContext;
	}

private void configureHeadlessProperty() {
//获取系统配置java.awt.headless的值，未配置使用默认值true
		System.setProperty(SYSTEM_PROPERTY_JAVA_AWT_HEADLESS,
				System.getProperty(SYSTEM_PROPERTY_JAVA_AWT_HEADLESS, Boolean.toString(this.headless)));
	}

SpringApplicationRunListeners listeners = getRunListeners(args);
listeners.starting(bootstrapContext, this.mainApplicationClass);

private SpringApplicationRunListeners getRunListeners(String[] args) {
    //将应用程序接收到的命令行参数组合成一个参数解决器
	ArgumentResolver argumentResolver = ArgumentResolver.of(SpringApplication.class, this);
	argumentResolver = argumentResolver.and(String[].class, args);
	//从META-INF/spring.factories 和 SpringApplicationHook 中获取，并启动SpringApplicationRunListeners实例
	List<SpringApplicationRunListener> listeners = getSpringFactoriesInstances(SpringApplicationRunListener.class,
			argumentResolver);
			//获取当前线程中的SpringApplicationHook，此处暂时有个疑问，没发现怎么设置这个SpringApplicationHook❓
	SpringApplicationHook hook = applicationHook.get();
	//如果hook 存在则将获取的SpringApplicationRunListener放入列表
	SpringApplicationRunListener hookListener = (hook != null) ? hook.getRunListener(this) : null;
	if (hookListener != null) {
		listeners = new ArrayList<>(listeners);
		listeners.add(hookListener);
	}
	return new SpringApplicationRunListeners(logger, listeners, this.applicationStartup);
}

private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
		DefaultBootstrapContext bootstrapContext, ApplicationArguments applicationArguments) {
	//创建并配置环境
	ConfigurableEnvironment environment = getOrCreateEnvironment();
	//配置环境，如果需要转换服务，添加ApplicationConversionService，另外委托给了configurePropertySources（属性源）和configureProfiles（配置文件），子类可以覆盖该方法或分别覆盖两者进行细粒度控制
	configureEnvironment(environment, applicationArguments.getSourceArgs());
	//将ConfigurationPropertySource支持附加到指定的环境
	ConfigurationPropertySources.attach(environment);
	//调用environmentPrepared方法
	listeners.environmentPrepared(bootstrapContext, environment);
	//将defaultProperties属性源移动到指定配置环境的最后
	DefaultPropertiesPropertySource.moveToEnd(environment);
	Assert.state(!environment.containsProperty("spring.main.environment-prefix"),
			"Environment prefix cannot be set via properties.");
			//绑定环境到SpringApplication
	bindToSpringApplication(environment);
	//非自定义环境配置，就将其转换为标准类型
	if (!this.isCustomEnvironment) {
		EnvironmentConverter environmentConverter = new EnvironmentConverter(getClassLoader());
		environment = environmentConverter.convertEnvironmentIfNecessary(environment, deduceEnvironmentClass());
	}
	//重新将ConfigurationPropertySource支持附加到指定的环境
	ConfigurationPropertySources.attach(environment);
	return environment;
}

private Banner printBanner(ConfigurableEnvironment environment) {
	//banner关闭，不打印
	if (this.bannerMode == Banner.Mode.OFF) {
		return null;
	}
	//获取资源加载器
	ResourceLoader resourceLoader = (this.resourceLoader != null) ? this.resourceLoader
			: new DefaultResourceLoader(null);
			//banner打印器
	SpringApplicationBannerPrinter bannerPrinter = new SpringApplicationBannerPrinter(resourceLoader, this.banner);
	if (this.bannerMode == Mode.LOG) {
		return bannerPrinter.print(environment, this.mainApplicationClass, logger);
	}
	return bannerPrinter.print(environment, this.mainApplicationClass, System.out);
}

protected ConfigurableApplicationContext createApplicationContext() {
		return this.applicationContextFactory.create(this.webApplicationType);
	}

private void prepareContext(DefaultBootstrapContext bootstrapContext, ConfigurableApplicationContext context,
		ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
		ApplicationArguments applicationArguments, Banner printedBanner) {
		//将指定环境设置到应用程序上下文中
	context.setEnvironment(environment);
	//应用后置处理器
	postProcessApplicationContext(context);
	//如果需要，添加AOT生成的初始化器
	addAotGeneratedInitializerIfNecessary(this.initializers);
	//应用ApplicationContextInitializer
	applyInitializers(context);
	//通知侦听器应用程序上下文已经准备好
	listeners.contextPrepared(context);
	// 关闭引导上下文
	bootstrapContext.close(context);
	if (this.logStartupInfo) {
		logStartupInfo(context.getParent() == null);
		logStartupProfileInfo(context);
	}
	 // 添加引导所必需的单例
	ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
	beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
	if (printedBanner != null) {
		beanFactory.registerSingleton("springBootBanner", printedBanner);
	}
	if (beanFactory instanceof AbstractAutowireCapableBeanFactory autowireCapableBeanFactory) {
	//设置循环引用
			autowireCapableBeanFactory.setAllowCircularReferences(this.allowCircularReferences);
		if (beanFactory instanceof DefaultListableBeanFactory listableBeanFactory) {
		
//设置是否允许覆盖
			listableBeanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
		}
	}
	if (this.lazyInitialization) {
	//设置延迟初始化
		context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
	}
	//设置一个PropertySourceOrderingBeanFactoryPostProcessor处理器
	context.addBeanFactoryPostProcessor(new PropertySourceOrderingBeanFactoryPostProcessor(context));
	if (!AotDetector.useGeneratedArtifacts()) {
		// Load the sources
		Set<Object> sources = getAllSources();
		Assert.notEmpty(sources, "Sources must not be empty");
		//将所有源bean加载到上下文中
		load(context, sources.toArray(new Object[0]));
	}
	//通知侦听器应用程序上下文已经加载完成
	listeners.contextLoaded(context);
}

private void refreshContext(ConfigurableApplicationContext context) {
		if (this.registerShutdownHook) {
			//如果需要，注册ShutdownHook以确保优雅关闭应用程序
			shutdownHook.registerApplicationContext(context);
		}
		//调用Spring的刷新应用程序上下文
		refresh(context);
	}

protected void afterRefresh(ConfigurableApplicationContext context, ApplicationArguments args) {
	}

listeners.started(context, timeTakenToStartup);

private void callRunners(ApplicationContext context, ApplicationArguments args) {
		List<Object> runners = new ArrayList<>();
		runners.addAll(context.getBeansOfType(ApplicationRunner.class).values());
		runners.addAll(context.getBeansOfType(CommandLineRunner.class).values());
		AnnotationAwareOrderComparator.sort(runners);
		for (Object runner : new LinkedHashSet<>(runners)) {
			if (runner instanceof ApplicationRunner applicationRunner) {
				callRunner(applicationRunner, args);
			}
			if (runner instanceof CommandLineRunner commandLineRunner) {
				callRunner(commandLineRunner, args);
			}
		}
	}

if (context.isRunning()) {
				Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);
				listeners.ready(context, timeTakenToReady);
			}