首先我们要先带着我们的疑问，spring boot是如何启动应用程序？去分析SpringBoot的启动源码。
我们在新建SpringBoot项目时，核心方法就是主类的run方法。
SpringApplication.run(ArchWebApplication.class, args)
我们点击run方法进入到源码中，这块传入的了一个我们当前程序主类的类对象以及主程序参数。
public static ConfigurableApplicationContext run(Class<?> primarySource,
String... args) {
return run(new Class<?>[] { primarySource }, args);
}
再往下走，调用本身的run方法，这里就开始初始化SpringApplication对象啦，然后在调用run方法。初始化SpringApplication对象时也是将主类的类对象传入进去，然后调用run方法，将主程序传进来的参数传进去。
public static ConfigurableApplicationContext run(Class<?>[] primarySources,
String[] args) {
return new SpringApplication(primarySources).run(args);
}
我们先来看SpringApplication对象初始化时都做了哪些操作。
同样调用自身的双参构造方法，null为传入的资源加载器。
public SpringApplication(Class<?>... primarySources) {
this(null, primarySources);
}
再往下走就到了初始化SpringApplication的核心逻辑啦。
public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
//首先是将传来的资源加载器进行赋值，当然我们知道这个资源加载器是null
this.resourceLoader = resourceLoader;
//然后在进行类对象的判空
Assert.notNull(primarySources, "PrimarySources must not be null");
//然后将传进来的类对像的数组转成list在转成set。
//（我估计这里是为了去重类对象，因为可以穿进来的可变参数有重复的，可变参数实质就是一个数组）。
this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
//deduceFromClasspath 方法的目的是用来判断应用是servlet还是reactive应用
this.webApplicationType = WebApplicationType.deduceFromClasspath();
//这一步的逻辑是从spring.factories文件中读取 key为ApplicationContextInitializer的类信息，采用反射实例化对象
//设置上下文信息
setInitializers((Collection) getSpringFactoriesInstances(
ApplicationContextInitializer.class));
//这一步的逻辑同上，也是从spring.factories文件中读取 key为ApplicationListener的类信息，采用反射实例化对象
//设置监听器
setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
//判断是否为main函数，配置主函数启动类 class信息
this.mainApplicationClass = deduceMainApplicationClass();
}
上面是一个创建SpringApplication的整体逻辑，那么我们在具体看一下 WebApplicationType.deduceFromClasspath()里面的逻辑是怎么样的。WebApplicationType本身是一个枚举类。
//一共三种方式返回服务条件的一种
static WebApplicationType deduceFromClasspath() {
//判断当前应用是不是 REACTIVE应用
if (ClassUtils.isPresent(WEBFLUX_INDICATOR_CLASS, null)
&& !ClassUtils.isPresent(WEBMVC_INDICATOR_CLASS, null)
&& !ClassUtils.isPresent(JERSEY_INDICATOR_CLASS, null)) {
return WebApplicationType.REACTIVE;
}
//判断是不是 非web应用
for (String className : SERVLET_INDICATOR_CLASSES) {
if (!ClassUtils.isPresent(className, null)) {
return WebApplicationType.NONE;
}
}
//都不是的话返回 web应用方式
return WebApplicationType.SERVLET;
}
ClassUtils.isPresent()这个方法的主要作用是通过反射判断相应的类存不存在。
public static boolean isPresent(String className, @Nullable ClassLoader classLoader) {
try {
forName(className, classLoader);
return true;
}
catch (IllegalAccessError err) {
throw new IllegalStateException("Readability mismatch in inheritance hierarchy of class [" +
className + "]: " + err.getMessage(), err);
}
catch (Throwable ex) {
// Typically ClassNotFoundException or NoClassDefFoundError...
return false;
}
}
ok，分析完WebApplicationType.deduceFromClasspath()，我们在来看一下getSpringFactoriesInstances()这个方法的核心逻辑。
private <T> Collection<T> getSpringFactoriesInstances(Class<T> type,
Class<?>[] parameterTypes, Object... args) {
//获取ClassLoader
ClassLoader classLoader = getClassLoader();
//这一步很重要，重点在于内部是从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;
}
我们来看一下，loadFactoryNames中都干了什么，它这里面的核心就在于加载配置文件，反射实例化对象
public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
String factoryClassName = factoryClass.getName();
return loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
}
//核心逻辑在这个方法
private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
//首先先去判断下Map中是否有值，有值的话，就直接返回，相当于一个本地缓存。
MultiValueMap<String, String> result = cache.get(classLoader);
if (result != null) {
return result;
}
try {
//如果Map没有值的话，获取资源目录下的spring.factories文件。加载配置
//源码中 FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories"
Enumeration<URL> urls = (classLoader != null ?
classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
result = new LinkedMultiValueMap<>();
//下面就是遍历放进map中
while (urls.hasMoreElements()) {
URL url = urls.nextElement();
UrlResource resource = new UrlResource(url);
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());
}
}
}
cache.put(classLoader, result);
return result;
}
catch (IOException ex) {
throw new IllegalArgumentException("Unable to load factories from location [" +
FACTORIES_RESOURCE_LOCATION + "]", ex);
}
}
OK，这里关于SpringApplication初始化的操作就已经完成啦，那么下面我们在一下run()方法里都做些什么操作。传进去的是主程序的参数。
public ConfigurableApplicationContext run(String... args) {
//创建StopWatch对象，用于记录服务启动的时间
StopWatch stopWatch = new StopWatch();
//记录服务启动开始时间
stopWatch.start();
//定义应用程序上下文
ConfigurableApplicationContext context = null;
Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
//配置运行程序的系统环境，以确保可正确的运行。
configureHeadlessProperty();
//获取在SpringApplication上的所有监听器。
SpringApplicationRunListeners listeners = getRunListeners(args);
//通知所有监听器，启动应用程序
listeners.starting();
try {
//封装应用程序的主程序参数
ApplicationArguments applicationArguments = new DefaultApplicationArguments(
args);
//准备应用环境，生成环境变量
ConfigurableEnvironment environment = prepareEnvironment(listeners,
applicationArguments);
configureIgnoreBeanInfo(environment);
//打印应用程序的banner
Banner printedBanner = printBanner(environment);
//创建应用上下文对象
context = createApplicationContext();
//从spring.factories中获取SpringBootExceptionReporter类型的异常解析器。
exceptionReporters = getSpringFactoriesInstances(
SpringBootExceptionReporter.class,
new Class[] { ConfigurableApplicationContext.class }, context);
//用已有的数据准备上下文，为刷新做准备
prepareContext(context, environment, listeners, applicationArguments,
printedBanner);
//启动应用程序上下文，通过refresh实现
refreshContext(context);
//上下文刷新后执行一些后置处理
afterRefresh(context, applicationArguments);
//记录结束时间
stopWatch.stop();
//判断是否需要记录应用程序的启动信息
if (this.logStartupInfo) {
new StartupInfoLogger(this.mainApplicationClass)
.logStarted(getApplicationLog(), stopWatch);
}
//通知所有监听器，应用程序已经启动，传递上下文对象和启动时间
listeners.started(context);
//运行所有已经注册的runner
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);
}
return context;
}
ok，下面我们来断点调试下springboot启动类的源码执行。
启动SpringBoot应用程序。
后面就是排序实例 ，返回实例。
剩下的就是我们上面画的那些流程啦。
ok，至此SpringBoot启动的全流程就已经完成啦，最后在总结一下大体的流程。
- 初始化SpringApplication，运行SpringApplication的run方法
- 读取 spring.factories 的多个初始化器和监听器
- 配置项目中环境变量、jvm配置信息、配置文件信息
- 预初始化环境，创建环境对象
- 创建Spring容器对象（ApplicationContext）
- 调用spring的refresh加载IOC容器、自动配置类，并创建bean等信息
- 调用很多监听器并传递上下文对象
- 运行相关runner
