# SpringBoot启动原理 #
1.创建SpringBoot时默认生成一个启动类
@SpringBootApplication
public class SpringBootWebApplication {
public static void main(String[] args) {
SpringApplication.run(SpringBootWebApplication.class, args);
}
}
2.启动时调用SpringApplication的run方法
public static ConfigurableApplicationContext run(Class<?> primarySource,
String... args) {
//调用SpringApplication类中的重载run方法
return run(new Class<?>[] { primarySource }, args);
}
public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
return new SpringApplication(primarySources).run(args);
}
3.此时调用两个方法:先创建一个SpringApplication对象,运行run方法
//创建SpringApplication对象,参数为Class<?>[SpringBootWebApplication.class]
new SpringApplication(primarySources);
//运行run方法
run(args);
4.创建SpringApplication对象时执行下面代码
public SpringApplication(Class<?>... primarySources) {
//调用重载构造方法
this(null, primarySources);
}
public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
//resourceLoader为null
this.resourceLoader = resourceLoader;
//primarySources为Class<?>[SpringBootWebApplication.class]
Assert.notNull(primarySources, "PrimarySources must not be null");
//此时primarySources由数组变为LinkedHashSet集合
this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
//4.1判断应用类型
this.webApplicationType = WebApplicationType.deduceFromClasspath();
//4.2从类路径下找到META‐INF/spring.factories配置的所有ApplicationContextInitializer；然后保存起来
setInitializers((Collection) getSpringFactoriesInstances(
ApplicationContextInitializer.class));
//4.3从类路径下找到ETA‐INF/spring.factories配置的所有ApplicationListener
setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
//4.4从多个配置类中找到有main方法的主配置类
this.mainApplicationClass = deduceMainApplicationClass();
}
4.1.调用WebApplicationType.deduceFromClasspath()方法判断应用类型
//判断当前应用是普通web应用、响应式web应用还是非web应用
static WebApplicationType deduceFromClasspath() {
//isPresent方法判断所提供的类名的类是否存在，且可以被加载
if (ClassUtils.isPresent(WEBFLUX_INDICATOR_CLASS, null)
&& !ClassUtils.isPresent(WEBMVC_INDICATOR_CLASS, null)
&& !ClassUtils.isPresent(JERSEY_INDICATOR_CLASS, null)) {
//应用是响应式web应用
return WebApplicationType.REACTIVE;
}
for (String className : SERVLET_INDICATOR_CLASSES) {
if (!ClassUtils.isPresent(className, null)) {
//非web应用
return WebApplicationType.NONE;
}
}
//普通web应用
return WebApplicationType.SERVLET;
}
4.2.从类路径下找到META‐INF/spring.factories配置的所有ApplicationContextInitializer；然后保存起来
setInitializers(
//4.2.1获取Spring工厂实例
(Collection) getSpringFactoriesInstances(
ApplicationContextInitializer.class));
4.2.1.获取Spring工厂实例
getSpringFactoriesInstances(
ApplicationContextInitializer.class)
//此处type参数为ApplicationContextInitializer.class
private <T> Collection<T> getSpringFactoriesInstances(Class<T> type) {
//调用重载方法
return getSpringFactoriesInstances(type, new Class<?>[] {});
}
private <T> Collection<T> getSpringFactoriesInstances(Class<T> type,
Class<?>[] parameterTypes, Object... args) {
//获取类加载器
ClassLoader classLoader = getClassLoader();
//4.2.1.1使用LinkedHashSet存放加载的工厂名称防止重复
Set<String> names = new LinkedHashSet<>(
SpringFactoriesLoader.loadFactoryNames(type, classLoader));
//4.2.1.2创建Spring工厂实例
List<T> instances = createSpringFactoriesInstances(type, parameterTypes,
classLoader, args, names);
//对实例进行排序
AnnotationAwareOrderComparator.sort(instances);
return instances;
}
4.2.1.1使用LinkedHashSet存放加载的工厂名称防止重复
Set<String> names = new LinkedHashSet<>(
SpringFactoriesLoader.loadFactoryNames(type, classLoader));
//加载工厂名称,此处factoryClass参数为ApplicationContextInitializer.class
public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
//此时factoryClassName为org.springframework.context.ApplicationContextInitializer
String factoryClassName = factoryClass.getName();
//加载Spring工厂,并从中获取key为org.springframework.context.ApplicationContextInitializer的value.此时值为:
//org.springframework.context.ApplicationContextInitializer=\
//org.springframework.boot.context.ConfigurationWarningsApplicationContextInitializer,\
//org.springframework.boot.context.ContextIdApplicationContextInitializer,\
//org.springframework.boot.context.config.DelegatingApplicationContextInitializer,\
//org.springframework.boot.web.context.ServerPortInfoApplicationContextInitializer
return loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
}
//加载Spring工厂
private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
//第一次调用该方法,此时cache只是一个空集合
MultiValueMap<String, String> result = cache.get(classLoader);
if (result != null) {
return result;
}
try {
//加载所有的/META-INF/spring.factories文件
Enumeration<URL> urls = (classLoader != null ?
classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
result = new LinkedMultiValueMap<>();
while (urls.hasMoreElements()) {
URL url = urls.nextElement();
UrlResource resource = new UrlResource(url);
//将spring.factories文件转为properties文件
Properties properties = PropertiesLoaderUtils.loadProperties(resource);
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());
}
}
}
//将所有的spring.factories文件中的数据存入cache中
cache.put(classLoader, result);
return result;
}
catch (IOException ex) {
throw new IllegalArgumentException("Unable to load factories from location [" +
FACTORIES_RESOURCE_LOCATION + "]", ex);
}
}
4.2.1.2创建Spring工厂实例
//创建Spring工厂实例
List<T> instances = createSpringFactoriesInstances(type, parameterTypes,
classLoader, args, names);
//遍历传入的names,对其进行实例化,放入instances中返回
private <T> List<T> createSpringFactoriesInstances(Class<T> type,
Class<?>[] parameterTypes, ClassLoader classLoader, Object[] args,
Set<String> names) {
List<T> instances = new ArrayList<>(names.size());
for (String name : names) {
try {
//根据name和classLoader获取Class对象
Class<?> instanceClass = ClassUtils.forName(name, classLoader);
Assert.isAssignable(type, instanceClass);
//获取指定参数类型的所有构造器，包括public的和非public的
Constructor<?> constructor = instanceClass
.getDeclaredConstructor(parameterTypes);
//创建实例化对象
T instance = (T) BeanUtils.instantiateClass(constructor, args);
//加如instances中
instances.add(instance);
}
catch (Throwable ex) {
throw new IllegalArgumentException(
"Cannot instantiate " + type + " : " + name, ex);
}
}
return instances;
}
4.3从类路径下找到ETA‐INF/spring.factories配置的所有ApplicationListener和4.2流程类似
5.运行run方法
/**
* 运行spring应用,创建并刷新新的spring容器
*/
public ConfigurableApplicationContext run(String... args) {
//首先创建开始停止的监听
StopWatch stopWatch = new StopWatch();
stopWatch.start();
ConfigurableApplicationContext context = null;
Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
//与awt应用有关的配置
configureHeadlessProperty();
//5.1从类路径下找到META‐INF/spring.factories获取SpringApplicationRunListeners
SpringApplicationRunListeners listeners = getRunListeners(args);
//回调所有的SpringApplicationRunListeners的starting方法
listeners.starting();
try {
//封装命令行参数
ApplicationArguments applicationArguments = new DefaultApplicationArguments(
args);
//5.2准备环境
ConfigurableEnvironment environment = prepareEnvironment(listeners,
applicationArguments);
configureIgnoreBeanInfo(environment);
//打印banner图标
Banner printedBanner = printBanner(environment);
//创建ioc容器,根据环境不同创建不同的ioc容器
context = createApplicationContext();
//出现异常用来查看异常报告
exceptionReporters = getSpringFactoriesInstances(
SpringBootExceptionReporter.class,
new Class[] { ConfigurableApplicationContext.class }, context);
//5.3准备上下文环境
prepareContext(context, environment, listeners, applicationArguments,
printedBanner);
//5.4刷新容器,ioc容器初始化流程
refreshContext(context);
//5.5从ioc容器中获取ApplicationRunner和CommandLineRunner并进行回调
afterRefresh(context, applicationArguments);
stopWatch.stop();
if (this.logStartupInfo) {
new StartupInfoLogger(this.mainApplicationClass)
.logStarted(getApplicationLog(), stopWatch);
}
listeners.started(context);
callRunners(context, applicationArguments);
}
catch (Throwable ex) {
handleRunFailure(context, ex, exceptionReporters, listeners);
throw new IllegalStateException(ex);
}
try {
listeners.running(context);
}
catch (Throwable ex) {
handleRunFailure(context, ex, exceptionReporters, null);
throw new IllegalStateException(ex);
}
//springboot启动完成返回ioic容器
return context;
}
5.2准备环境
private ConfigurableEnvironment prepareEnvironment(
SpringApplicationRunListeners listeners,
ApplicationArguments applicationArguments) {
// 获取或创建环境
ConfigurableEnvironment environment = getOrCreateEnvironment();
//配置环境
configureEnvironment(environment, applicationArguments.getSourceArgs());
//回调所有的SpringApplicationRunListeners的environmentPrepared方法,表示环境准备完成
listeners.environmentPrepared(environment);
//将环境绑定到spring应用中
bindToSpringApplication(environment);
if (!this.isCustomEnvironment) {
environment = new EnvironmentConverter(getClassLoader())
.convertEnvironmentIfNecessary(environment, deduceEnvironmentClass());
}
ConfigurationPropertySources.attach(environment);
return environment;
}
5.3准备上下文环境
private void prepareContext(ConfigurableApplicationContext context,
ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
ApplicationArguments applicationArguments, Banner printedBanner) {
//设置环境到ioc容器中
context.setEnvironment(environment);
//使用后置处理器给ioc容器注册bean
postProcessApplicationContext(context);
//回调4.2步骤中获取的所有ApplicationContextInitializer的initialize方法
applyInitializers(context);
//回调5.1步骤中获取的所有SpringApplicationRunListener的contextPrepared方法
listeners.contextPrepared(context);
//记录日志
if (this.logStartupInfo) {
logStartupInfo(context.getParent() == null);
logStartupProfileInfo(context);
}
// 注册命令行参数
ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
if (printedBanner != null) {
//将banner注册进来
beanFactory.registerSingleton("springBootBanner", printedBanner);
}
if (beanFactory instanceof DefaultListableBeanFactory) {
((DefaultListableBeanFactory) beanFactory)
.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
}
// 获取主类
Set<Object> sources = getAllSources();
Assert.notEmpty(sources, "Sources must not be empty");
load(context, sources.toArray(new Object[0]));
//回调5.1步骤中获取的所有SpringApplicationRunListener的contextLoaded方法
listeners.contextLoaded(context);
}
5.5从ioc容器中获取ApplicationRunner和CommandLineRunner并进行回调,其中ApplicationRunner优先级高于CommandLineRunner
protected void afterRefresh(ConfigurableApplicationContext context,
ApplicationArguments args) {
}
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) {
callRunner((ApplicationRunner) runner, args);
}
if (runner instanceof CommandLineRunner) {
callRunner((CommandLineRunner) runner, args);
}
}
}
SpringBoot启动原理
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
