原创者：文思
开发任何一个SpingBoot项目都会用到
@SpringBootApplication
public class DemoApplication {
public static void main(String[]args) {
SpringApplication.run(DemoApplication.class,args);
}
}
从上面代码可以看出，Annotation定义（@SpringBootApplication）和类定义（SpringApplication.run）最显眼，所以要揭开SpringBoot的启动神秘面纱，我们从这两位开始。
一：SpringBootApplication注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {
@Filter(type =
FilterType.CUSTOM, classes = TypeExcludeFilter.class),
@Filter(type =
FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication{
}
依次分析如下：
@Target用于提示该注解使用的地方和范围，来自于:jdkjava.lang.annotation.Target;
取值有：
public enum ElementType {
/** Class, interface (including annotation type), or enum
declaration */
TYPE,
/** Field declaration (includes enum constants) */
FIELD,
/** Method declaration */
METHOD,
/** Formal parameter declaration */
PARAMETER,
/** Constructor declaration */
CONSTRUCTOR,
/** Local variable declaration */
LOCAL_VARIABLE,
/** Annotation type declaration */
ANNOTATION_TYPE,
/** Package declaration */
PACKAGE,
/**
* Typeparameter declaration
*@since1.8
*/
TYPE_PARAMETER,
/**
* Use of atype
*@since1.8
*/
TYPE_USE
}
根据注释说明总结：
(重点说明下：ElementType. PACKAGE。它并不是使用在一般的类中，而是用在固定的文件package-info.java中。这里需要强调命名一定是“package-info”。由于package-info.java并不是一个合法的类，使用eclipse创建类的方式会提示不合法，所以需要以创建文件的方式来创建package-info.java）
@Retention用于提示注解被保留多长时间，来自于:jdkjava.lang.annotation.Retention;有三种取值：
public enum RetentionPolicy {
/**
* Annotations are to be discarded by the compiler.
*/
SOURCE,
/**
* Annotations are to be recorded in the class file by the compiler
* but need not be retained by the VM at run time.This is the default
* behavior.
*/
CLASS,
/**
* Annotations are to be recorded in the class file by the compiler and
* retained by the VM at run time, so they may be read reflectively.
*@seejava.lang.reflect.AnnotatedElement
*/
RUNTIME
}
RetentionPolicy.SOURCE保留在源码级别，被编译器抛弃(@Override就是此类)；RetentionPolicy.CLASS被编译器保留在编译后的类文件级别，但是被虚拟机丢弃；RetentionPolicy.RUNTIME保留至运行时，可以被反射读取。
@Documented用于描述其它类型的annotation应该被作为被标注的程序成员的公共API，因此可以被例如javadoc此类的工具文档化。Documented是一个标记注解，没有成员。
@Inherited元注解是一个标记注解，@Inherited阐述了某个被标注的类型是被继承的。如果一个使用了@Inherited修饰的annotation类型被用于一个class，则这个annotation将被用于该class的子类。
注意：@Inherited annotation类型是被标注过的class的子类所继承。类并不从它所实现的接口继承annotation，方法并不从它所重载的方法继承annotation。
当@Inherited annotation类型标注的annotation的Retention是RetentionPolicy.RUNTIME，则反射API增强了这种继承性。如果我们使用java.lang.reflect去查询一个@Inherited annotation类型的annotation时，反射代码检查将展开工作：检查class和其父类，直到发现指定的annotation类型被发现，或者到达类继承结构的顶层。
重头戏来了：
org.springframework.boot.SpringBootConfiguration
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
public @interface SpringBootConfiguration{
}
@SpringBootConfiguration点开查看发现里面还是应用了@Configuration
所以，如果我们使用如下的SpringBoot启动类，整个SpringBoot应用依然可以与之前的启动类功能对等：
@Configuration
@EnableAutoConfiguration
@ComponentScan
publicclass Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
@SpringBootConfiguration(@Configuration)
来自于:org.springframework.context.annotation.Configuration它就是JavaConfig形式的Spring Ioc容器的配置类使用的那个@Configuration。SpringBoot社区推荐使用基于JavaConfig的配置形式.
XML跟config配置方式的区别：
Spring2.2及以内是不是很常用这种。
基于JavaConfig的配置方式：
@Configuration
publicclass MockConfiguration{
@Bean
public MockService mockService(){
return newMockServiceImpl(dependencyService());
}
@Bean
public DependencyServicedependencyService(){
return new DependencyServiceImpl();
}
}
org.springframework.context.annotation.ComponentScan
@ComponentScan这个注解在Spring中很重要，它对应XML配置中的元素，@ComponentScan的功能其实就是自动扫描并加载符合条件的组件（比如@Component和@Repository等）或者bean定义，最终将这些bean定义加载到IoC容器中。
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Repeatable(ComponentScans.class)
public @interface ComponentScan{
注：@Repeatable是java8中才有的注解，将语法糖转化为注解值为数组形式(指的是，在计算机语言中添加某种语法，这种语法能使程序员更方便的使用语言开发程序，同时增强程序代码的可读性，避免出错的机会；但是这种语法对语言的功能并没有影响。
java中的泛型，变长参数，自动拆箱/装箱，条件编译等都是
我们可以通过basePackages等属性来细粒度的定制@ComponentScan自动扫描的范围，如果不指定，则默认Spring框架实现会从声明@ComponentScan所在类的package进行扫描。
注：所以SpringBoot的启动类最好是放在root package下，因为默认不指定basePackages。
其中@Filter(type=FilterType.CUSTOM, classes = TypeExcludeFilter.class)是ComponentScan的内部注解，顾名思义过滤器，CUSTOM顾名思义自定义，用途自己猜吧。我猜在进行扫描时可以调用自定义的过滤器。
@EnableAutoConfiguration：
个人感觉@EnableAutoConfiguration这个Annotation最为重要，所以放在最后来解读，大家是否还记得Spring框架提供的各种名字为@Enable开头的Annotation定义？比如@EnableScheduling、@EnableCaching、@EnableMBeanExport等，@EnableAutoConfiguration的理念和做事方式其实一脉相承，简单概括一下就是，借助@Import的支持，收集和注册特定场景相关的bean定义。
·@EnableScheduling是通过@Import将Spring调度框架相关的bean定义都加载到IoC容器。
·@EnableMBeanExport是通过@Import将JMX相关的bean定义加载到IoC容器。
而@EnableAutoConfiguration也是借助@Import的帮助，将所有符合自动配置条件的bean定义加载到IoC容器，仅此而已！
@SuppressWarnings("deprecation")
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(EnableAutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration{
其中，最关键的要属@Import(EnableAutoConfigurationImportSelector.class)，借助EnableAutoConfigurationImportSelector，@EnableAutoConfiguration可以帮助SpringBoot应用将所有符合条件的@Configuration配置都加载到当前SpringBoot创建并使用的IoC容器。
自动配置幕后英雄：SpringFactoriesLoader属于Spring框架私有的一种扩展方案，其主要功能就是从指定的配置文件META-INF/spring.factories加载配置。
配合@EnableAutoConfiguration使用的话，它更多是提供一种配置查找的功能支持，即根据@EnableAutoConfiguration的完整类名org.springframework.boot.autoconfigure.EnableAutoConfiguration作为查找的Key,获取对应的一组@Configuration类�
@EnableAutoConfiguration自动配置的魔法骑士就变成了：从classpath中搜寻所有的META-INF/spring.factories配置文件，并将其中org.springframework.boot.autoconfigure.EnableutoConfiguration对应的配置项通过反射（Java Refletion）实例化为对应的标注了@Configuration的JavaConfig形式的IoC容器配置类，然后汇总为一个并加载到IoC容器.
具体源码请大家慢慢看，复杂去了。
深入探索SpringApplication执行流程
SpringApplication的run方法的实现是本次主线，该方法的主要流程大体可以归纳如下：
(1)
publicstaticvoidmain(String[]args){
SpringApplication.run(DemoApplication.class,args);
}
publicstaticConfigurableApplicationContext run(Objectsource, String...args) {
returnrun(newObject[] {source},args);
}
publicstaticConfigurableApplicationContext run(Object[]sources, String[]args) {
returnnewSpringApplication(sources).run(args);
}
publicConfigurableApplicationContext run(String...args) {
StopWatchstopWatch=newStopWatch();
stopWatch.start();
ConfigurableApplicationContextcontext=null;
FailureAnalyzersanalyzers=null;
configureHeadlessProperty();
SpringApplicationRunListenerslisteners= getRunListeners(args);
listeners.starting();
try{
ApplicationArgumentsapplicationArguments=newDefaultApplicationArguments( args);
ConfigurableEnvironmentenvironment= prepareEnvironment(listeners, applicationArguments);
BannerprintedBanner= printBanner(environment);
context = createApplicationContext();
analyzers=newFailureAnalyzers(context);
prepareContext(context,environment,listeners,applicationArguments,
printedBanner);
refreshContext(context);
afterRefresh(context,applicationArguments);
listeners.finished(context,null);
stopWatch.stop();
if(this.logStartupInfo) {
newStartupInfoLogger(this.mainApplicationClass)
. logStarted(getApplicationLog(),stopWatch);
}
returncontext;
}catch(Throwableex) {
handleRunFailure(context,listeners,analyzers,ex);
thrownewIllegalStateException(ex);
}
}
如果我们使用的是SpringApplication的静态run方法，那么，这个方法里面首先要创建一个SpringApplication对象实例，然后调用这个创建好的SpringApplication的实例方法。在SpringApplication实例初始化的时候，它会提前做几件事情：
根据classpath里面是否存在某个特征类（org.springframework.web.context.ConfigurableWebApplicationContext）来决定是否应该创建一个为Web应用使用的ApplicationContext类型。
使用SpringFactoriesLoader在应用的classpath中查找并加载所有可用的ApplicationContextInitializer。
使用SpringFactoriesLoader在应用的classpath中查找并加载所有可用的ApplicationListener。推断并设置main方法的定义类。
public static ConfigurableApplicationContext run(Object[]sources, String[]args) {
return new SpringApplication(sources).run(args);
}
public SpringApplication(Object...sources) {
initialize(sources);
·}
@SuppressWarnings({"unchecked","rawtypes"})
private void initialize(Object[]sources) {
if(sources!=null&&sources.length> 0) {
this.sources.addAll(Arrays.asList(sources));
}
this.webEnvironment=deduceWebEnvironment();
setInitializers((Collection)getSpringFactoriesInstances(ApplicationContextInitializer.class));
setListeners((Collection)getSpringFactoriesInstances(ApplicationListener.class));
this.mainApplicationClass= deduceMainApplicationClass();
}
(2)
SpringApplication实例初始化完成并且完成设置后，就开始执行run方法的逻辑了，方法执行伊始，首先遍历执行所有通过SpringFactoriesLoader可以查找到并加载的SpringApplicationRunListener。调用它们的started()方法，告诉这些SpringApplicationRunListener，“嘿，SpringBoot应用要开始执行咯！”
SpringApplicationRunListenerslisteners=getRunListeners(args);
listeners.starting();
3） 创建并配置当前Spring Boot应用将要使用的Environment（包括配置要使用的PropertySource以及Profile）。
4）遍历调用所有SpringApplicationRunListener的environmentPrepared()的方法，告诉他们：“当前SpringBoot应用使用的Environment准备好了”
5）如果SpringApplication的showBanner属性被设置为true，则打印banner。
6）根据用户是否明确设置了applicationContextClass类型以及初始化阶段的推断结果，决定该为当前SpringBoot应用创建什么类型的ApplicationContext并创建完成，然后根据条件决定是否添加ShutdownHook，决定是否使用自定义的BeanNameGenerator，决定是否使用自定义的ResourceLoader，当然，最重要的，将之前准备好的Environment设置给创建好的ApplicationContext使用。
7）ApplicationContext创建好之后，SpringApplication会再次借助Spring-FactoriesLoader，查找并加载classpath中所有可用ApplicationContext-Initializer，然后遍历调用这些ApplicationContextInitializer的initialize（applicationContext）方法来对已经创建好的ApplicationContext进行进一步的处理。
8）遍历调用所有SpringApplicationRunListener的contextPrepared()方法。
9）最核心的一步，将之前通过@EnableAutoConfiguration获取的所有配置以及其他形式的IoC容器配置加载到已经准备完毕的ApplicationContext。
10）遍历调用所有SpringApplicationRunListener的contextLoaded()方法。
11）调用ApplicationContext的refresh()方法，完成IoC容器可用的最后一道工序。
12）查找当前ApplicationContext中是否注册有CommandLineRunner，如果有，则遍历执行它们。
13）正常情况下，遍历执行SpringApplicationRunListener的finished()方法、（如果整个过程出现异常，则依然调用所有SpringApplicationRunListener的finished()方法，只不过这种情况下会将异常信息一并传入处理）
去除事件通知点后，整个流程如下：
有时间我在看看细节讲一下。
