SpringBoot的启动过程原理

SpringBoot的启动过程原理：

1.创建SpringApplication

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
	//进行信息的保存
	this.resourceLoader = resourceLoader;
	Assert.notNull(primarySources, "PrimarySources must not be null");
	this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
	//判断当前应用的类型。我们这里使用的是原生serlvet
	this.webApplicationType = WebApplicationType.deduceFromClasspath();
	
	//bootstrappers：初始启动引导器（List<Bootstrapper>）：去spring.factories文件中找 org.springframework.boot.Bootstrapper
	this.bootstrappers = new ArrayList<>(getSpringFactoriesInstances(Bootstrapper.class));
	
	//去spring.factories找 ApplicationContextInitializer，找到的结果放在List<ApplicationContextInitializer<?>> initializers
	setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
	
	//去spring.factories找 ApplicationListener，找到的结果放在List<ApplicationListener<?>> listeners
	setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
	this.mainApplicationClass = deduceMainApplicationClass();
}

# 分析setInitializers((Collection) 详细情况
1.执行	private <T> Collection<T> getSpringFactoriesInstances(Class<T> type)
2.	
private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
	ClassLoader classLoader = getClassLoader();
	//在Spirng.factories文件中找ApplicationContextInitializer
	//只要见到(SpringFactoriesLoader.loadFactoryNames(type, classLoader));就是去spring.factories中找该自动配置类
	Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
	List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
	AnnotationAwareOrderComparator.sort(instances);
	return instances;
}

2.运行SpringApplication

public ConfigurableApplicationContext run(String... args) {
	//记录一个当前访问的时间
	StopWatch stopWatch = new StopWatch();
	stopWatch.start();
	
	//创建引导上下文（Context环境）createBootstrapContext(),
	//获取到所有之前的 bootstrappers 挨个执行 intitialize() 来完成对引导启动器上下文环境设置
	DefaultBootstrapContext bootstrapContext = createBootstrapContext();

	ConfigurableApplicationContext context = null;
	//让当前应用进入headless模式。java.awt.headles
	configureHeadlessProperty();
	//getSpringFactoriesInstances(SpringApplicationRunListener.class, types, this, args),
	//在spring.factories配置文件中查找SpringApplicationRunListeners 的自动配置类
	SpringApplicationRunListeners listeners = getRunListeners(args);
	
	//遍历 SpringApplicationRunListener 调用 starting 方法；
	//相当于通知所有感兴趣系统正在启动过程的人，项目正在 starting
	listeners.starting(bootstrapContext, this.mainApplicationClass);
	try {
		//保存命令行参数；ApplicationArguments
		ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
		
		//准备环境 prepareEnvironment（）;
		ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
		//返回或者创建基础环境信息对象。StandardServletEnvironment
		configureIgnoreBeanInfo(environment);
		//打印banner
		Banner printedBanner = printBanner(environment);
		//创建ioc容器
		context = createApplicationContext();
		
		context.setApplicationStartup(this.applicationStartup);
		//准备环境
		//保存环境信息
		//IOC容器的后置处理流程。
		//应用初始化器；applyInitializers；
		// 遍历所有的 ApplicationContextInitializer 。调用 initialize.。来对ioc容器进行初始化扩展功能
		//遍历所有的 listener 调用 contextPrepared。EventPublishRunListenr；通知所有的监听器contextPrepared
		//所有的监听器 调用 contextLoaded。通知所有的监听器 contextLoaded；
		prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);

		//创建容器中的所有组件（Spring注解）
		refreshContext(context);
		
		//所有监听 器 调用 listeners.started(context); 通知所有的监听器 started
		afterRefresh(context, applicationArguments);
		
		stopWatch.stop();
		if (this.logStartupInfo) {
			new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
		}
		//所有监听器调用listeners.started方法通知所有listener监听started
		listeners.started(context);
		
		//调用所有runners
		//获取容器中的ApplicationRunner
		//获取容器中的CommonLineRunner
		//合并所有runner并且按照@Order进行排序
		//遍历所有的runner。调用 run 方法
		callRunners(context, applicationArguments);
	}
	catch (Throwable ex) {
		handleRunFailure(context, ex, listeners);
		throw new IllegalStateException(ex);
	}
	
	try {
		listeners.running(context);
	}
	
	//如果以上有异常，
	//调用Listener 的 failed
	//调用所有监听器的 running 方法  listeners.running(context); 通知所有的监听器 running 
	//running如果有问题。继续通知 failed 。调用所有 Listener 的 failed；通知所有的监听器 failed
	catch (Throwable ex) {
		handleRunFailure(context, ex, null);
		throw new IllegalStateException(ex);
	}
	return context;
}