Spring Boot教程(三)(启动原理)(上)

字数 2718阅读 324

                                                                                                                          原创者:文思

开发任何一个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()方法,只不过这种情况下会将异常信息一并传入处理)

去除事件通知点后,整个流程如下:

有时间我在看看细节讲一下。

推荐阅读更多精彩内容