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

binecy
989 阅读5分钟

SpringBoot深入理解 -- @AliasFor注解的作用
SpringBoot源码解析 -- SpringBoot启动过程
SpringBoot源码解析 -- AutoConfigure的实现原理
SpringBoot源码解析 -- @ComponentScan的实现原理
SpringBoot源码解析 -- @Value,@Autowired实现原理
SpringBoot源码解析 -- Tomcat，SpringMVC启动
SpringBoot源码解析 -- Logging，Environment启动

源码分析基于spring boot 2.1

本文通过阅读源码，分析SpringBoot的启动过程。

先看一个例子

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

例子很简单，本文主要关注三个问题

  1. SpringApplication#run方法的作用
  2. SpringApplication#run方法中MyApplication.class参数的作用
  3. SpringApplication#run方法中args参数的作用

SpringApplication#run

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

先构造SpringApplication实例，再调用run方法

SpringApplication#构造方法

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
	this.resourceLoader = resourceLoader;

	this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources)); 	// #1
	this.webApplicationType = WebApplicationType.deduceFromClasspath();	//#2
	setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));	//#3
	setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class)); //#4
	this.mainApplicationClass = deduceMainApplicationClass();	// #5
}

#1 设置SpringApplication#primarySources，注意这里primarySources参数就是run方法的第一个参数
#2 判断当前应用是JAVA应用，SERVLET应用或REACTIVE应用。
#3 加载spring.factories中配置的ApplicationContextInitializer实现类，将结果存放到SpringApplication#initializers
#4 加载spring.factories中配置的ApplicationListener实现类，将结果存放到SpringApplication#listeners
#5 获取main方法所在Class

SpringApplication#getSpringFactoriesInstances -> SpringFactoriesLoader#loadSpringFactories

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
	MultiValueMap<String, String> result = cache.get(classLoader);
	if (result != null) {
		return result;
	}

	try {
		Enumeration<URL> urls = (classLoader != null ?
				classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
				ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));	//#1
		result = new LinkedMultiValueMap<>();
		while (urls.hasMoreElements()) {
			URL url = urls.nextElement();
			UrlResource resource = new UrlResource(url);
			Properties properties = PropertiesLoaderUtils.loadProperties(resource);	//#2
			for (Map.Entry<?, ?> entry : properties.entrySet()) {
				String factoryClassName = ((String) entry.getKey()).trim();
				for (String factoryName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) {
					result.add(factoryClassName, factoryName.trim());	//#3
				}
			}
		}
		cache.put(classLoader, result);
		return result;
	}
	catch (IOException ex) {
		throw new IllegalArgumentException("Unable to load factories from location [" +
				FACTORIES_RESOURCE_LOCATION + "]", ex);
	}
}

#1 FACTORIES_RESOURCE_LOCATION就是字符串"META-INF/spring.factories"，这里读取jar中META-INF/spring.factories文件内容
#2 加载spring.factories文件（格式为Properties）
#3 读取Properties内容，缓存结果

spring.factories格式为

# Initializers
org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,\
org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener

key为spring扩展接口（或声明功能的注解），value为对应的功能实现类的列表

SpringApplication#run

public ConfigurableApplicationContext run(String... args) {
	StopWatch stopWatch = new StopWatch();	// #1
	stopWatch.start();
	ConfigurableApplicationContext context = null;
	Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
	configureHeadlessProperty();	// #2
	SpringApplicationRunListeners listeners = getRunListeners(args);	// #3
	listeners.starting();	// #4
	try {
		ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);	// #5
		ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);	// #6
		configureIgnoreBeanInfo(environment);	// #7
		Banner printedBanner = printBanner(environment);
		context = createApplicationContext();	// #8
		exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
				new Class[] { ConfigurableApplicationContext.class }, context);
		prepareContext(context, environment, listeners, applicationArguments, printedBanner);	// #9
		refreshContext(context);	// #10
		afterRefresh(context, applicationArguments);	// #11
		stopWatch.stop();
		if (this.logStartupInfo) {
			new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
		}
		listeners.started(context);	// #12
		callRunners(context, applicationArguments);	// #13
	}
	catch (Throwable ex) {
		handleRunFailure(context, ex, exceptionReporters, listeners);
		throw new IllegalStateException(ex);
	}

	try {
		listeners.running(context);	// #14
	}
	catch (Throwable ex) {
		handleRunFailure(context, ex, exceptionReporters, null);
		throw new IllegalStateException(ex);
	}
	return context;
}

#1 开始计时（计算初始化需要花费多少时间）
#2 配置java.awt.headless
#3 获取spring.factories中配置的SpringApplicationRunListener实现类
SpringApplicationRunListeners是SpringApplicationRunListener的组合，SpringApplicationRunListener是SpringBoot中新增接口，通过它来间接调用 ApplicationListener。
该接口实现类为EventPublishingRunListener，他的构造方法中需传入SpringApplication，并获取SpringApplication#listeners属性。
SpringApplicationRunListener组件很重要，SpringBoot中很多扩展也是通过listerner实现的，如日志系统的启动
#4 发送ApplicationStartedEvent事件
#5 命令行参数处理
#6 构建Environment
#7 处理spring.beaninfo.ignore配置
#8 创建ApplicationContext
#9 prepareContext
#10 refreshContext
#11 afterRefresh，预留扩展方法
#12 发送ApplicationStartedEvent事件
#13 运行ApplicationRunner，CommandLineRunner
#14 发送ApplicationReadyEvent事件

SpringApplication#prepareEnvironment

private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
		ApplicationArguments applicationArguments) {
	ConfigurableEnvironment environment = getOrCreateEnvironment();	// #1
	configureEnvironment(environment, applicationArguments.getSourceArgs());	// #2
	ConfigurationPropertySources.attach(environment);
	listeners.environmentPrepared(environment);	// #3
	bindToSpringApplication(environment);
	if (!this.isCustomEnvironment) {
		environment = new EnvironmentConverter(getClassLoader()).convertEnvironmentIfNecessary(environment,
				deduceEnvironmentClass());
	}
	ConfigurationPropertySources.attach(environment);
	return environment;
}

#1 创建一个Environment
#2 将SpringApplication#run中的可变参数列表传递给Environment
回到文章开头说的第3个问题，关于MyApplication#run中的args参数
我们在启动SpringBoot时，可以添加命令行参数，如java -jar MyApplication.jar --spring.profiles.active=dev
命令行参数--spring.profiles.active=dev会传递给main方法，main方法中需要将其传递给SpringApplication#run方法，
这里将命令行参数添加Environment中，作为一个PropertySource。
必须在main方法中将args参数传给SpringApplication#run方法，否则会造成命令行的参数失效。
#3 发送ApplicationEnvironmentPreparedEvent事件

SpringApplication#createApplicationContext

protected ConfigurableApplicationContext createApplicationContext() {
	Class<?> contextClass = this.applicationContextClass;
	if (contextClass == null) {
		try {
			switch (this.webApplicationType) {
			case SERVLET:
				contextClass = Class.forName(DEFAULT_SERVLET_WEB_CONTEXT_CLASS);	// #1
				break;
			case REACTIVE:
				contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);	// #2
				break;
			default:
				contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);	// #3
			}
		}
		catch (ClassNotFoundException ex) {
			throw new IllegalStateException(
					"Unable create a default ApplicationContext, " + "please specify an ApplicationContextClass",
					ex);
		}
	}
	return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);	// #4
}

#1 SERVLET应用，选择AnnotationConfigServletWebServerApplicationContext
#2 REACTIVE应用，选择AnnotationConfigReactiveWebServerApplicationContext
#3 JAVA应用，选择AnnotationConfigApplicationContext
#4 构造对应的Spring Context
AnnotationConfigServletWebServerApplicationContext#构造方法 -> AnnotatedBeanDefinitionReader#构造方法 -> AnnotationConfigUtils#registerAnnotationConfigProcessors
这里注册一些实现SpringBoot功能必须的PostProcessor

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
		BeanDefinitionRegistry registry, @Nullable Object source) {

	DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
	if (beanFactory != null) {
		if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
			beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
		}
		if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
			beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
		}
	}

	Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);

	if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
		RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);	//#1
		def.setSource(source);
		beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
	}

	if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
		RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);	//#2
		def.setSource(source);
		beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
	}

	...

	return beanDefs;
}

#1 注册ConfigurationClassPostProcessor，该PostProcessor处理@Configuration等注解
#2 注册AutowiredAnnotationBeanPostProcessor，该PostProcessor处理@Value，@Autowired等注解

SpringApplication#prepareContext

private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment,
		SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {
	context.setEnvironment(environment);	
	postProcessApplicationContext(context);
	applyInitializers(context);	//#1
	listeners.contextPrepared(context);	//#2
	if (this.logStartupInfo) {
		logStartupInfo(context.getParent() == null);
		logStartupProfileInfo(context);
	}
	// Add boot specific singleton beans
	ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
	beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
	if (printedBanner != null) {
		beanFactory.registerSingleton("springBootBanner", printedBanner);
	}
	if (beanFactory instanceof DefaultListableBeanFactory) {
		((DefaultListableBeanFactory) beanFactory)
				.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
	}
	// Load the sources
	Set<Object> sources = getAllSources();
	Assert.notEmpty(sources, "Sources must not be empty");
	load(context, sources.toArray(new Object[0]));	//#3
	listeners.contextLoaded(context);	//#4
}

#1 调用ApplicationContextInitializer#initialize
#2 调用SpringApplicationRunListener#contextPrepared方法
#3 getAllSources获取primarySources以及所有的PropertySource，并解析为BeanDefinition注册到Spring上下文中（后面要使用）
PropertySource（属性源）用于Environment重新获取配置属性。
primarySources就是SpringApplication#run方法的第一个参数
回到文章开头第2个问题，
通过SpringApplication#run方法的MyApplication.class参数，这里将MyApplication的BeanDefinition注册到Spring上下文中，后面Spring就是可以获取MyApplication上的@SpringBootApplication等注解了。
#4 发送ApplicationContextInitializedEvent事件

SpringApplication#refreshContext
之前解析Spring Context的文章已经说过refreshContext操作了。

SpringApplication#callRunners

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

#1 获取ApplicationRunner和CommandLineRunner
#2 调用对应的run方法

如果您觉得本文不错，欢迎关注我的微信公众号，您的关注是我坚持的动力！

avatar
文章
阅读
粉丝