97. SpringBoot-启动流程分析第一篇

 

 

感谢网友给我的打赏，感谢Leonzhang的支付宝打赏，非常感谢！

        《从零开始学Spring Boot》系列博客已经介绍了不少篇幅了，有些博友说要介绍下理论的知识，确实本系列博客都是偏实现类的文章，这节就介绍下理论的知识吧。我们就来一起看看Spring Boot启动流程。

我们找到我们程序的入口代码：

public static void main(String[] args) {

       /*

        * 在main方法进行启动我们的应用程序.

        */

       SpringApplication.run(App.class, args);

}

上面核心代码是：SpringApplication.run

我们进入之后会进入到SpringApplication.java类中：

/**

     * Static helper that can be used to run a {@link SpringApplication} from the

     * specified source using default settings.

     * @param source the source to load

     * @param args the application arguments (usually passed from a Java main method)

     * @return the running {@link ApplicationContext}

     */

    public static ConfigurableApplicationContext run(Object source, String... args) {

       return run(new Object[] { source }, args);

    }

 

进入重构run()方法：

/**

     * Static helper that can be used to run a {@link SpringApplication} from the

     * specified sources using default settings and user supplied arguments.

     * @param sources the sources to load

     * @param args the application arguments (usually passed from a Java main method)

     * @return the running {@link ApplicationContext}

     */

    public static ConfigurableApplicationContext run(Object[] sources, String[] args) {

       return new SpringApplication(sources).run(args);

    }

       这里new了一个SpringApplication对象出来，然后调用其run方法，我们先看看这个new SpringApplication的过程：

   public SpringApplication(Object... sources) {

       initialize(sources);

    }

 

我们看下具体的initialize（）方法：

   @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();

    }

 

从上面的代码我们看到初始化做了以下几件事情：

this.webEnvironment = deduceWebEnvironment();

这一个方法决定创建的是一个WEB应用还是一个SPRING的标准Standalone应用。如果入方法可以看到其是怎么判断的：

private boolean deduceWebEnvironment() {

       for (String className : WEB_ENVIRONMENT_CLASSES) {

           if (!ClassUtils.isPresent(className, null)) {

              return false;

           }

       }

       return true;

    }

其中WEB_ENVIRONMENT_CLASSES是一个静态常量数组：

privatestaticfinal String[] WEB_ENVIRONMENT_CLASSES = { "javax.servlet.Servlet",

         "org.springframework.web.context.ConfigurableWebApplicationContext" };

可以看到是根据org.springframework.util.ClassUtils的静态方法去判断classpath里面是否有WEB_ENVIRONMENT_CLASSES包含的类，如果有都包含则返回true则表示启动一个WEB应用，否则返回false启动一个标准Spring的应用。

 

可以看到是否启动一个WEB应用就是取决于classpath下是否有javax.servlet.Servlet和

org.springframework.web.context.ConfigurableWebApplicationContext。

 

进入下一个阶段：

setInitializers((Collection) getSpringFactoriesInstances(

              ApplicationContextInitializer.class));

这个方法则是初始化classpath下的所有的可用的ApplicationContextInitializer

 

下一步：

setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));

这个方法则是初使化classpath下的所有的可用的ApplicationListener

 

下一步：

this.mainApplicationClass = deduceMainApplicationClass();

我们找到对应的deduceMainApplicationClass()方法：

   private Class<?> deduceMainApplicationClass() {

       try {

           StackTraceElement[] stackTrace = new RuntimeException().getStackTrace();

           for (StackTraceElement stackTraceElement : stackTrace) {

              if ("main".equals(stackTraceElement.getMethodName())) {

                  return Class.forName(stackTraceElement.getClassName());

              }

           }

       }

       catch (ClassNotFoundException ex) {

           // Swallow and continue

       }

       return null;

    }

最后找出main方法的全类名并返回其实例并设置到SpringApplication的this.mainApplicationClass完成初始化。然后调用SpringApplication实例的run方法来启动应用，代码如下：

public ConfigurableApplicationContext run(String... args) {

       StopWatch stopWatch = new StopWatch();

       stopWatch.start();

       ConfigurableApplicationContext context = null;

       FailureAnalyzers analyzers = null;

       configureHeadlessProperty();

       SpringApplicationRunListeners listeners = getRunListeners(args);

       listeners.started();

       try {

           ApplicationArguments applicationArguments = new DefaultApplicationArguments(

                  args);

           ConfigurableEnvironment environment = prepareEnvironment(listeners,

                  applicationArguments);

           Banner printedBanner = printBanner(environment);

           context = createApplicationContext();

           analyzers = new FailureAnalyzers(context);

           prepareContext(context, environment, listeners, applicationArguments,

                  printedBanner);

           refreshContext(context);

           afterRefresh(context, applicationArguments);

           listeners.finished(context, null);

           stopWatch.stop();

           if (this.logStartupInfo) {

              new StartupInfoLogger(this.mainApplicationClass)

                     .logStarted(getApplicationLog(), stopWatch);

           }

           return context;

       }

       catch (Throwable ex) {

           handleRunFailure(context, listeners, analyzers, ex);

           throw new IllegalStateException(ex);

       }

    }

 

这里我们看以下代码：

ApplicationArguments applicationArguments = new DefaultApplicationArguments(

                  args);

           ConfigurableEnvironment environment = prepareEnvironment(listeners,

                  applicationArguments);

           Banner printedBanner = printBanner(environment);

           context = createApplicationContext();

           analyzers = new FailureAnalyzers(context);

           prepareContext(context, environment, listeners, applicationArguments,

                  printedBanner);

           refreshContext(context);

           afterRefresh(context, applicationArguments);

首先是获取启动时传入参数args并初始化为ApplicationArguments对象SpringApplication.run(Application.class, args);取这里传入值。 然后配置SpringBoot应用的环境：

ConfigurableEnvironment environment = prepareEnvironment(listeners,

                  applicationArguments);

 

Banner printedBanner = printBanner(environment);

则打印标志这个方法不说明，因为没有什么实质性作用，反应到控制台则是以下的效果如果确实想玩玩修改一下标志，那可以在项目的classpath下新建一个banner.txt文件，我们在之前的文章也介绍过如何进行更改，这里不做过多的介绍。

 

然后下面代码就是比较核心的：

context = createApplicationContext();

           analyzers = new FailureAnalyzers(context);

           prepareContext(context, environment, listeners, applicationArguments,

                  printedBanner);

           refreshContext(context);

           afterRefresh(context, applicationArguments);

 

首先是createApplicationContext()方法：

protected ConfigurableApplicationContext createApplicationContext() {

       Class<?> contextClass = this.applicationContextClass;

       if (contextClass == null) {

           try {

              contextClass = Class.forName(this.webEnvironment

                     ? DEFAULT_WEB_CONTEXT_CLASS : DEFAULT_CONTEXT_CLASS);

           }

           catch (ClassNotFoundException ex) {

              thrownew IllegalStateException(

                     "Unable create a default ApplicationContext, "

                            + "please specify an ApplicationContextClass",

                     ex);

           }

       }

       return (ConfigurableApplicationContext) BeanUtils.instantiate(contextClass);

    }

 

可以看出根据这前初始化过程初始化的this.webEnvironment来决定初始化一个什么容器。如果classpath下是否有javax.servlet.Servlet和

org.springframework.web.context.ConfigurableWebApplicationContext类，

则使用DEFAULT_WEB_CONTEXT_CLASS初始化容器，如果不存在则用DEFAULT_CONTEXT_CLASS初始化容器。

public static final String DEFAULT_CONTEXT_CLASS = "org.springframework.context."

            + "annotation.AnnotationConfigApplicationContext";

 

    /**

     * The class name of application context that will be used by default for web

     * environments.

     */

    publicstaticfinal String DEFAULT_WEB_CONTEXT_CLASS = "org.springframework."

            + "boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext";

 

以上是代码指定了容器的类名，最后通过Spring的工具类初始化容器类bean

BeanUtils.instantiate(contextClass);

 

完成容器的创建工作。然后执行以下的几个步骤完成整个容器的创建与启动以及bean的注入功能。

prepareContext(context, environment, listeners, applicationArguments,

                  printedBanner);

 

以下这一句代码是实现spring-boot-starter-*的自动化配置的关键。

refreshContext(context);

afterRefresh(context, applicationArguments);

至此通过SpringBoot启动的容器已经构造完成。这里忽略了启动流程中的收集各种Listener，创建Environment及Environment的初始化的因为这些地方都是SpringBoot提供的各种扩展点，后面的博客会详细的说明各个扩展点的用处以及扩展的方式。

 

我们下节博客会更详细的介绍Spring Boot怎么内嵌Tomcat的。

 

 à悟空学院：https://t.cn/Rg3fKJD

学院中有Spring Boot相关的课程！点击「阅读原文」进行查看！

SpringBoot视频：http://t.cn/A6ZagYTi

Spring Cloud视频：http://t.cn/A6ZagxSR

SpringBoot Shiro视频：http://t.cn/A6Zag7IV

SpringBoot交流平台：https://t.cn/R3QDhU0

SpringData和JPA视频：http://t.cn/A6Zad1OH

SpringSecurity5.0视频：http://t.cn/A6ZadMBe

Sharding-JDBC分库分表实战：http://t.cn/A6ZarrqS

分布式事务解决方案「手写代码」：http://t.cn/A6ZaBnIr

评论

2 楼 林祥纤 2016-12-21  

yuchao2015 写道

看不懂 

先会用就好了。

1 楼 yuchao2015 2016-12-20  

看不懂