一个简单的SB程序如下，点击main方法左边的原谅色的三角形就能把程序启动起来，虽然什么功能都没有，但是启动做了很多处理，加载了很多支持多种功能的组件(类似使用new ClassPathXmlApplicationContext()启动一个Spring程序，其中加载了很多东西)
@SpringBootApplication
public class SpringBootDemoApplication {
public static void main(String[] args) {
SpringApplication.run(SpringBootDemoApplication.class, args);
}
}
分析的入口就是从SpringApplication的run方法开始，而@SpringBootApplication注解在后续的处理中会用到，所以暂时忽略
1.入口
进入run方法
public static ConfigurableApplicationContext run(Class<?> primarySource,
String... args) {
return run(new Class<?>[] { primarySource }, args);
}
public static ConfigurableApplicationContext run(Class<?>[] primarySources,
String[] args) {
return new SpringApplication(primarySources).run(args);
}
2.初始化SpringApplication
首先初始化了SpringApplication，然后再调用其run方法，那么先看下SpringApplication的构造方法里的逻辑
public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
this.resourceLoader = resourceLoader;
Assert.notNull(primarySources, "PrimarySources must not be null");
// 即demo里的SpringBootDemoApplication对应的Class对象集合
this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
// 应用的类型，共三种类型
// reactive、servlet 、非web应用
this.webApplicationType = deduceWebApplicationType();
// 获取spring.factories中配置的ApplicationContextInitializer的实现类并实例化，最后放到集合当中
setInitializers((Collection) getSpringFactoriesInstances(
ApplicationContextInitializer.class));
// 原理同上
setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
// 找到执行main方法的那个类的Class对象，即demo中的SpringBootDemoApplication对应的Class对象
this.mainApplicationClass = deduceMainApplicationClass();
}
2.1获取应用类型
在SpringApplication构造方法里，调用了deduceWebApplicationType来判断是什么类型的应用，那么SpringBoot是如何判断的呢？往里进去看下具体实现
private WebApplicationType deduceWebApplicationType() {
//REACTIVE_WEB_ENVIRONMENT_CLASS = org.springframework.web.reactive.DispatcherHandler
//MVC_WEB_ENVIRONMENT_CLASS = org.springframework.web.servlet.DispatcherServlet
if (ClassUtils.isPresent(REACTIVE_WEB_ENVIRONMENT_CLASS, null)
&& !ClassUtils.isPresent(MVC_WEB_ENVIRONMENT_CLASS, null)) {
return WebApplicationType.REACTIVE;
}
//WEB_ENVIRONMENT_CLASSES=javax.servlet.Servlet
// 或者org.springframework.web.context.ConfigurableWebApplicationContext
for (String className : WEB_ENVIRONMENT_CLASSES) {
if (!ClassUtils.isPresent(className, null)) {
return WebApplicationType.NONE;
}
}
return WebApplicationType.SERVLET;
}
ClassUtils.isPresent方法中尝试加载传入的类，如果加载成功，则返回true，如果失败则返回false，SpringBoot使用这种方式在判断当前是什么类型的应用。
从假设我们应用中什么依赖都没有加入，那么WEB_ENVIRONMENT_CLASSES、REACTIVE_WEB_ENVIRONMENT_CLASS或者MVC_WEB_ENVIRONMENT_CLASS都是加载失败的，最终返回WebApplicationType.NONE。
从另一个方面来说，如果我们想构建一个SpringMVC的web应用，那么只需要加入如下依赖：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
此时，SpringBoot会帮我们间接依赖SpringMVC所需要的包，那么就间接引入了org.springframework.web.context.ConfigurableWebApplicationContext这个包，由于SpringMVC底层是基于Servlet，那么会引入javax.servlet.Servlet相关的包。加了上面这一个依赖之后，deduceWebApplicationType方法就会返回WebApplicationType.SERVLET。
后续SpringBoot会根据deduceWebApplicationType的返回类型，来做不同的初始化，这也算是SpringBoot自动化的其中一个体现。
2.2 Spring的扩展机制
在构造方法中，会初始化initializers和listeners两个几个，里面的对应的类型分别是ApplicationContextInitializer和ApplicationListener类型的实例。
- ApplicationContextInitializer：用于上下文刷新前(refreshContext)的回调处理
- ApplicationListener：用于事件的通知
这两个集合都是通过getSpringFactoriesInstances方法去加载的，而核心的实现就是Spring的扩展机制。
SpringBoot会基于这个机制，会提供一些系统内置的类(分别实现ApplicationContextInitializer和ApplicationListener)，让系统自动的调用对应的实现，而这些内置类的加载则是通过getSpringFactoriesInstances方法实现的：
private <T> Collection<T> getSpringFactoriesInstances(Class<T> type,
Class<?>[] parameterTypes, Object... args) {
//获取类加载器
ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
// 获取对应的类名
Set<String> names = new LinkedHashSet<>(
SpringFactoriesLoader.loadFactoryNames(type, classLoader));
//实例化
List<T> instances = createSpringFactoriesInstances(type, parameterTypes,
classLoader, args, names);
AnnotationAwareOrderComparator.sort(instances);
return instances;
}
SpringFactoriesLoader就是扩展机制的核心实现，其大概逻辑就是，查找META-INF文件下的spring.factories文件，通过对应类型获取配置好的类名，以ApplicationContextInitializer为例，引入的jar包中，其下面的spring.factories文件如下：
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
org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,\
org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener
故getSpringFactoriesInstances(ApplicationContextInitializer.class)得到的是的是上面6个类的实例对象集合，ApplicationListener就不再分析
基于此，我们也可以在工程的对应路径下加入spring.factories文件，并用上面的规则，加入自己的实现来扩展对应的功能
3.SpringApplication.run方法
当SpringApplication构造完成，就进入到run方法，进行真正的初始化步骤
public ConfigurableApplicationContext run(String... args) {
StopWatch stopWatch = new StopWatch();
stopWatch.start();
ConfigurableApplicationContext context = null;
Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
//设置awt相关属性
configureHeadlessProperty();
// 通过扩展机制获取SpringApplicationRunListener的实现类，并封装成SpringApplicationRunListeners对象
// 目前只有一个实现EventPublishingRunListener
SpringApplicationRunListeners listeners = getRunListeners(args);
// 发布ApplicationStartingEvent事件
listeners.starting();
try {
ApplicationArguments applicationArguments = new DefaultApplicationArguments(
args);
//环境准备
ConfigurableEnvironment environment = prepareEnvironment(listeners,
applicationArguments);
//设置需要忽略的Bean信息
configureIgnoreBeanInfo(environment);
Banner printedBanner = printBanner(environment);
//根据应用类型创建对应的ApplicationContext
context = createApplicationContext();
//获取错误报告处理器
exceptionReporters = getSpringFactoriesInstances(
SpringBootExceptionReporter.class,
new Class[] { ConfigurableApplicationContext.class }, context);
//刷新上下文前的准备工作
prepareContext(context, environment, listeners, applicationArguments,
printedBanner);
//刷新上下文，即Spring的核心流程，IOC，AOP，Bean初始化等流程
refreshContext(context);
//刷新完成后置处理
afterRefresh(context, applicationArguments);
stopWatch.stop();
if (this.logStartupInfo) {
new StartupInfoLogger(this.mainApplicationClass)
.logStarted(getApplicationLog(), stopWatch);
}
//发布ApplicationStartedEvent事件
listeners.started(context);
callRunners(context, applicationArguments);
}
catch (Throwable ex) {
//....
}
//发布ApplicationReadyEvent事件
listeners.running(context);
return context;
}
下面对核心步骤进行分析
3.1 环境准备
环境主要指的是Environment，Environment主要包括两部分功能：
- profile
- properties
其中profile是Environment自身的功能，而properties相关功能则是由Environment继承的接口PropertyResolver提供
prepareEnvironment方法会构建一个ConfigurableEnvironment实例，并对其进行初始化
private ConfigurableEnvironment prepareEnvironment(
SpringApplicationRunListeners listeners,
ApplicationArguments applicationArguments) {
// 根据应用类型返回不同的实例
ConfigurableEnvironment environment = getOrCreateEnvironment();
// properties和profile相关处理
configureEnvironment(environment, applicationArguments.getSourceArgs());
//发布ApplicationEnvironmentPreparedEvent事件
listeners.environmentPrepared(environment);
bindToSpringApplication(environment);
if (this.webApplicationType == WebApplicationType.NONE) {
environment = new EnvironmentConverter(getClassLoader())
.convertToStandardEnvironmentIfNecessary(environment);
}
ConfigurationPropertySources.attach(environment);
return environment;
}
先看下getOrCreateEnvironment方法
private ConfigurableEnvironment getOrCreateEnvironment() {
if (this.environment != null) {
return this.environment;
}
if (this.webApplicationType == WebApplicationType.SERVLET) {
return new StandardServletEnvironment();
}
return new StandardEnvironment();
}
由于是Servlet的web应用，则返回StandardServletEnvironment实例，其他情况则返回StandardEnvironment(StandardEnvironment是StandardServletEnvironment的父类)。这里为什么Servlet应用需要特殊处理呢？
前面说过Environment包括properties和profile，我们知道Servlet的properties来源和其他类型的应用相比，还有ServletContext里的参数，那么Servlet应用需要另外的解析工作(基础解析工作由StandardEnvironment完成)，而这个工作需要由StandardServletEnvironment特殊处理。
在其父类AbstractEnvironment的构造方法中，会调用到customizePropertySources方法，这个方法由子类重写来自定义解析策略（实际是加入处理的PropertySource），StandardServletEnvironment的customizePropertySources方法如下：
@Override
protected void customizePropertySources(MutablePropertySources propertySources) {
propertySources.addLast(new StubPropertySource(SERVLET_CONFIG_PROPERTY_SOURCE_NAME));
propertySources.addLast(new StubPropertySource(SERVLET_CONTEXT_PROPERTY_SOURCE_NAME));
if (JndiLocatorDelegate.isDefaultJndiEnvironmentAvailable()) {
propertySources.addLast(new JndiPropertySource(JNDI_PROPERTY_SOURCE_NAME));
}
super.customizePropertySources(propertySources);
}
这里看到该方法中加入两个PropertySource用于Servlet特有的属性解析，然后再调用父类StandardEnvironment的方法保证基础的属性解析也没有问题，看下StandardEnvironment的方法
@Override
protected void customizePropertySources(MutablePropertySources propertySources) {
propertySources.addLast(new MapPropertySource(SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME, getSystemProperties()));
propertySources.addLast(new SystemEnvironmentPropertySource(SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME, getSystemEnvironment()));
}
这里加入了两个PropertySource用于解析其他属性，即System.getProperties()和System.getEnv()两个方法所附带的属性。
- 至于PropertySource所涉及的属性解析原理，这里不再展开，后续会另起文章详细分析属性解析原理。
环境Environment的准备中，主要是为属性解析和profile做了准备工作，例如添加了PropertySource待后续参数获取使用
3.2 创建对应的ApplicationContext
创建上下文主要交由createApplicationContext处理
public static final String DEFAULT_WEB_CONTEXT_CLASS = "org.springframework.boot."
+ "web.servlet.context.AnnotationConfigServletWebServerApplicationContext";
public static final String DEFAULT_REACTIVE_WEB_CONTEXT_CLASS = "org.springframework."
+ "boot.web.reactive.context.AnnotationConfigReactiveWebServerApplicationContext";
public static final String DEFAULT_CONTEXT_CLASS = "org.springframework.context."
+ "annotation.AnnotationConfigApplicationContext";
protected ConfigurableApplicationContext createApplicationContext() {
Class<?> contextClass = this.applicationContextClass;
if (contextClass == null) {
try {
switch (this.webApplicationType) {
case SERVLET:
contextClass = Class.forName(DEFAULT_WEB_CONTEXT_CLASS);
break;
case REACTIVE:
contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);
break;
default:
contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);
}
}
catch (ClassNotFoundException ex) {
throw new IllegalStateException(
"Unable create a default ApplicationContext, "
+ "please specify an ApplicationContextClass",
ex);
}
}
return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
}
逻辑比较简单，根据应用类型创建不同的上下文对象
3.3 刷新上下文前的准备工作
该工作交由prepareContext处理：
private void prepareContext(ConfigurableApplicationContext context,
ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
ApplicationArguments applicationArguments, Banner printedBanner) {
context.setEnvironment(environment);
// 后置处理，注册BeanNameGenerator和设置ResourceLoader
postProcessApplicationContext(context);
// 遍历initializers集合内的ApplicationContextInitializer实例进行调用
applyInitializers(context);
// 发布事件，目前看到的实现为空
listeners.contextPrepared(context);
// 将之前封装的参数对象注册到容器中
context.getBeanFactory().registerSingleton("springApplicationArguments",
applicationArguments);
if (printedBanner != null) {
context.getBeanFactory().registerSingleton("springBootBanner", printedBanner);
}
// 即上文提到的primarySources
Set<Object> sources = getAllSources();
// 将我们的启动类注册到容器中
load(context, sources.toArray(new Object[0]));
//发布ApplicationPreparedEvent事件
listeners.contextLoaded(context);
}
3.3.1 postProcessApplicationContext
protected void postProcessApplicationContext(ConfigurableApplicationContext context) {
if (this.beanNameGenerator != null) {
context.getBeanFactory().registerSingleton(
AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR,
this.beanNameGenerator);
}
if (this.resourceLoader != null) {
if (context instanceof GenericApplicationContext) {
((GenericApplicationContext) context)
.setResourceLoader(this.resourceLoader);
}
if (context instanceof DefaultResourceLoader) {
((DefaultResourceLoader) context)
.setClassLoader(this.resourceLoader.getClassLoader());
}
}
}
代码逻辑很简单，但是该方法中beanNameGenerator和resourceLoader都为空，所以这个地方是Springboot留的一个扩展点，可以将自定义的设置进去
3.3.2 applyInitializers
protected void applyInitializers(ConfigurableApplicationContext context) {
for (ApplicationContextInitializer initializer : getInitializers()) {
Class<?> requiredType = GenericTypeResolver.resolveTypeArgument(
initializer.getClass(), ApplicationContextInitializer.class);
Assert.isInstanceOf(requiredType, context, "Unable to call initializer.");
initializer.initialize(context);
}
}
在前面的分析中，Spring会从spring.factories中获取ApplicationContextInitializer的实现并加入到集合当中，而这里就是真正调用的地方，具体的每个实现后续在相关功能中进行分析
3.3.3 load
protected void load(ApplicationContext context, Object[] sources) {
if (logger.isDebugEnabled()) {
logger.debug(
"Loading source " + StringUtils.arrayToCommaDelimitedString(sources));
}
BeanDefinitionLoader loader = createBeanDefinitionLoader(
getBeanDefinitionRegistry(context), sources);
if (this.beanNameGenerator != null) {
loader.setBeanNameGenerator(this.beanNameGenerator);
}
if (this.resourceLoader != null) {
loader.setResourceLoader(this.resourceLoader);
}
if (this.environment != null) {
loader.setEnvironment(this.environment);
}
loader.load();
}
将启动类封装成一个BeanDefinitionLoader，然后设置beanNameGenerator、resourceLoader、environment，最后调用load方法，将启动类注册到容器当中。
主要是创建了一个AnnotatedGenericBeanDefinition，然后使用BeanDefinitionRegistry，以beanName为key，将其注册到容器中。
这里涉及了Spring的知识，就不再详细展开。
3.4 刷新上下文
private void refreshContext(ConfigurableApplicationContext context) {
refresh(context);
if (this.registerShutdownHook) {
try {
context.registerShutdownHook();
}
catch (AccessControlException ex) {
// Not allowed in some environments.
}
}
}
refresh为Spring的核心流程，即org.springframework.context.support.AbstractApplicationContext#refresh，进行bean的创建等等一些核心流程。
另外会注册一个核心关闭钩子。
