- 先贴上启动流程图
1.启动入口 （SrpingApplication）
springboot的启动类 @SpringBootApplication +（main方法）+ new SpringApplication().run(XXXX.class, args)
@SpringBootApplication
public class TestApplication {
public static void main(String[] args) {
SpringApplication application = new SpringApplication();
application.run(TestApplication.class, args);
}
}
1.1 @SpringBootApplication 注解
通过源码发现该注解只是@Configuration，@EnableAutoConfiguration，@ComponentScan 三个注解的组合，这是在springboot 1.5以后为这三个注解做的一个简写。接下来简单说下这三个注解的功能：
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration //1.1.1 注册为配置类
@EnableAutoConfiguration //1.1.2 配置可自动装配
@ComponentScan(excludeFilters = { //1.1.3 声明可扫描Bean
@Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
...
}
1.1.1 @SpringBootConfiguration
该注解就是spirng ioc容器中java config 配置方式的@Configuration ，注册当前类为spring ioc容器的配置类。
搭配@bean注解创建一个简单spring ioc配置类
@Configuration
public class Conf {
@Bean
public Car car() {
Car car = new Car();
car.setWheel(wheel());
return car;
}
@Bean
public Wheel wheel() {
return new Wheel();
}
}
1.1.2 @EnableAutoConfiguration
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class) //最为重要
public @interface EnableAutoConfiguration {
String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
/**
* Exclude specific auto-configuration classes such that they will never be applied.
* @return the classes to exclude
*/
Class<?>[] exclude() default {};
/**
* Exclude specific auto-configuration class names such that they will never be
* applied.
* @return the class names to exclude
* @since 1.3.0
*/
String[] excludeName() default {};
}
@EnableAutoConfiguration借助@Import的帮助，将所有符合自动配置条件的bean定义加载到IoC容器，会根据类路径中的jar依赖为项目进行自动配置，如：添加了spring-boot-starter-web依赖，会自动添加Tomcat和Spring MVC的依赖，Spring Boot会对Tomcat和Spring MVC进行自动配置。
最关键的要属@Import(EnableAutoConfigurationImportSelector.class) ，借助EnableAutoConfigurationImportSelector，@EnableAutoConfiguration可以帮助SpringBoot应用将所有符合条件的@Configuration配置都加载到当前SpringBoot创建并使用的IoC容器。就像一只“八爪鱼”一样，借助于Spring框架原有的一个工具类：SpringFactoriesLoader的支持，@EnableAutoConfiguration可以智能的自动配置功效才得以大功告成！
1.1.3 @ComponentScan
@ComponentScan这个注解在Spring中很重要，它对应XML配置中的元素，@ComponentScan的功能其实就是自动扫描并加载符合条件的组件（比如@Component和@Repository等）或者bean定义，最终将这些bean定义加载到IoC容器中。
我们可以通过basePackages等属性来细粒度的定制@ComponentScan自动扫描的范围，如果不指定，则默认Spring框架实现会从声明@ComponentScan所在类的package进行扫描。
注：所以SpringBoot的启动类最好是放在root package下，因为默认不指定basePackages。
2.构造器（Constructor）
/**
* Create a new {@link SpringApplication} instance. The application context will load
* beans from the specified primary sources (see {@link SpringApplication class-level}
* documentation for details. The instance can be customized before calling
* {@link #run(String...)}.
* @param resourceLoader the resource loader to use
* @param primarySources the primary bean sources
* @see #run(Class, String[])
* @see #setSources(Set)
*/
@SuppressWarnings({ "unchecked", "rawtypes" })
public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
this.resourceLoader = resourceLoader;
Assert.notNull(primarySources, "PrimarySources must not be null");
this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
//2.1 判断当前程序类型
this.webApplicationType = WebApplicationType.deduceFromClasspath();
//2.2 使用SpringFactoriesLoader 实例化所有可用的初始器
setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
//2.3 使用SpringFactoriesLoader 实例化所有可用的监听器
setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
//2.4 配置应用主方法所在类
this.mainApplicationClass = deduceMainApplicationClass();
}
2.1 判断当前程序类型
根据classpath里面是否存在某个特征类
（org.springframework.web.context.ConfigurableWebApplicationContext）来决定是否应该创建一个为Web应用使用的ApplicationContext类型。
/**
* The application should not run as a web application and should not start an
* embedded web server.
*/
NONE,
/**
* The application should run as a servlet-based web application and should start an
* embedded servlet web server.
*/
SERVLET,
/**
* The application should run as a reactive web application and should start an
* embedded reactive web server.
*/
REACTIVE;
3.启动方法（RUN）
查看SpringBootApplication.run方法的源码就可以发现SpringBoot启动的流程主要分为两大阶段：
- 初始化
SpringApplication运行SpringApplication - 运行
SpringApplication的过程
其中运行SpringApplication的过程又可以细分为以下几个部分：
1）SpringApplicationRunListeners 引用启动监控模块
2）ConfigrableEnvironment配置环境模块和监听：包括创建配置环境、加载属性配置文件和配置监听
3）ConfigrableApplicationContext配置应用上下文：包括配置应用上下文对象、配置基本属性和刷新应用上下文
3.1 初始化SpringApplication
步骤1进行SpringApplication的初始化，配置基本的环境变量、资源、构造器、监听器，初始化阶段的主要作用是为运行SpringApplication实例对象启动环境变量准备以及进行必要的资源构造器的初始化动作，代码如下：
public SpringApplication(ResourceLoader resourceLoader, Object... sources){
this.resourceLoader = resourceLoader;
initialize(source);
}
@SupressWarnings({"unchecked","rowtypes"})
private void initialize(Object[] sources){
if(sources != null && sources.length > 0){
this.sources.addAll(Arrays.asList(sources));
}
this.WebEnvironment = deduceWebEnvironment;
setInitiallizers((Collection) getSpringFactoriesInstances(ApplicationContextInitiallizer.class));
setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
this.mainApplicationClass = deduceMainApplicationClass();
}
SpringApplication方法的核心就是this.initialize(sources)初始化方法，SpringApplication通过调用该方法完成初始化工作。deduceWebEnvironment方法用来判断当前应用的环境，该方法通过获取两个类来判断当前环境是否是Web环境。而getSpringFactoriesInstances方法主要用来从spring.factories文件中找出Key为ApplicationContextInitiallizer的类并实例化，然后调用setInitiallizer方法设置到SpringApplication的initiallizer属性中，找到它所有应用的初始化器。接着调用setListener方法设置应用监听器，这个过程可以找到所有应用程序的监听器，然后找到应用启动主类名称。
3.2 运行SpringApplication
SpringBoot正式启动加载过程，包括启动流程监控模块、配置环境加载模块、ApplicationContext容器上下文环境加载模块。refreshContext方法刷新应用上下文并进行自动化配置模块加载，也就是上文提到的SpringFactoriesLoader根据指定classpath加载META-INF/spring.factories文件的配置，实现自动配置核心功能。运行SpringApplication的主要代码如下:
public ConfigurableApplicationContext run(String... args) {
ConfigurableApplicationContext context = null;
FailureAnalyzer analyzer = null;
configureHeadlessProperty();
// 步骤1
SpringApplicationRunListeners listeners = getRunListeners(args);
listeners.starting();
try{
// 步骤2
ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
Banner printBanner = printBanner(environment);
// 步骤3
context = createApplicationContext();
prepareContext(context, environment, listeners, applicationArguments, printBanner);
refreshContext(context);
afterRefresh(context, applicationArguments);
listeners.finished(context, null);
// 省略
return context;
}
}
3.1 SpringApplciationRunListener应用启动监控模块
应用启动监控模块对应上述源码中的注释步骤1到步骤2之间的两行代码，它创建了应用的监听器SpringApplicationRunListeners并开始监听，监控模块通过调用getSpringFactoriesInstances私有协议从META-INF/spring.factories文件中取得SpringApplicationRunListener监听器实例。
当前事件监听器SpringApplicationRunListener中只有一个EventPublishingRunlistener广播事件监听器，它的starting方法会封装成SpringApplicatiionEvent事件广播出去，被SpringApplication中配置的listener监听。这一步骤执行完成后也会同时通知SpringBoot其他模块目前监听初始化已经完成，可以开始执行启动方案了。
3.2 ConfigurableEnviroment 配置环境模块和监听
对应上述源码注释中的步骤2到步骤3之间的几行代码，下面分解步骤说明：
(1) 创建配置环境，创建应用程序的环境信息。如果是Web程序，创建StandardServletEnvironment;否则创建StandardEnviroment；
(2) 加载属性配置文件，将配置文件加入监听器对象中(SpringApplicationRunListeners)。通过configPropertySource方法设置properties配置文件，通过执行configProfies方法设置profiles；
(3) 配置监听，发布environmentPrepared事件，及调用ApplicationListener#onApplicationEvent方法，通知SpringBoot应用的environment已经准备完成。
3.3 ConfigurableApplicationContext配置应用上下文
对应源码中的步骤3下面的几行代码，下面分解步骤说明：
（1）配置Spring容器应用上下文对象，它的作用是创建Run方法的返回对象ConfigurableApplicationContext（应用配置上下文），此类主要继承了ApplicationLifeCycle、Closeable接口，而ApplicationContext是Spring框架中负责Bean注入容器的主要载体，负责bean加载、配置管理、维护bean之间依赖关系及Bean生命周期管理。
（2）配置基本属性，对应prepareContext方法将listener、environment、banner、applicationArguments等重要组件与Spring容器上下文对象关联。借助SpringFactoriesLoader查找可用的ApplciationContextInitailizer, 它的initialize方法会对创建好的ApplicationContext进行初始化，然后它会调用SpringApplicationRunListener#contextPrepared方法，此时SpringBoot应用的ApplicationContext已经准备就绪，为刷新应用上下文准备好了容器。
（3）刷新应用上下文，对应源码中的refreshContext(context)方法将通过工程模式产生应用上下文中所需的bean。实现spring-boot-starter-*(mybatis、redis等)自动化配置的关键，包括spring.factories的加载、bean的实例化等核心工作。然后调用SpringApplicationRunListener#finish方法告诉SprignBoot应用程序，容器已经完成ApplicationContext装载。
