Spring Boot启动过程

对于Spring Boot项目来说只需要如下代码就可以启动整个项目

public static void main(String[] args) {
    SpringApplication.run(OrderApplication.class, args);
}

那么Spring容器，Web容器等等是怎么启动的？

1. new SpringApplication

   /**
    * 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));
       this.webApplicationType = WebApplicationType.deduceFromClasspath();
       setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
       setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
       this.mainApplicationClass = deduceMainApplicationClass();
   }
   

   • WebApplicationType.deduceFromClasspath();推断Web容器类型，具体参考容器推断

   • getSpringFactoriesInstances(ApplicationContextInitializer.class)
     从Spring factories中获取ApplicationContextInitializer.class对应的实现类，具体参考Spring factories

   •   //把对应的实现加进Initializers集合
       setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
       //把对应的实现加进Listeners集合
       setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
     

   • this.mainApplicationClass = 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;
     }
     

     至此，完成了SpringApplication的初始化

2. 调用SpringApplication的run方法

   public ConfigurableApplicationContext run(String... args) {
           //一个工具类，用于计算启动时间
       StopWatch stopWatch = new StopWatch();
       stopWatch.start();
       ConfigurableApplicationContext context = null;
       Collection exceptionReporters = new ArrayList<>();
       configureHeadlessProperty();
       SpringApplicationRunListeners listeners = getRunListeners(args);
       listeners.starting();
       try {
           ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
           ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
           configureIgnoreBeanInfo(environment);
           Banner printedBanner = printBanner(environment);
           context = createApplicationContext();
           exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
                   new Class[] { ConfigurableApplicationContext.class }, context);
           prepareContext(context, environment, listeners, applicationArguments, printedBanner);
           refreshContext(context);
           afterRefresh(context, applicationArguments);
           stopWatch.stop();
           if (this.logStartupInfo) {
               new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
           }
           listeners.started(context);
           callRunners(context, applicationArguments);
       }
       catch (Throwable ex) {
           handleRunFailure(context, ex, exceptionReporters, listeners);
           throw new IllegalStateException(ex);
       }
   
       try {
           listeners.running(context);
       }
       catch (Throwable ex) {
           handleRunFailure(context, ex, exceptionReporters, null);
           throw new IllegalStateException(ex);
       }
       return context;
   }
   

   •   //获取SpringApplicationRunListener接口对应的实现然后封装成SpringApplicationRunListeners，其实就是内部维护了一个集合
       SpringApplicationRunListeners listeners = getRunListeners(args);
       //观察者模式，循环调用内部集合进行通知
       listeners.starting();
     

   • ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);创建准备Environment对象

     private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments) {
         // 根据推断的web应用类型，创建对应的Environment
         ConfigurableEnvironment environment = getOrCreateEnvironment();
         // 对environment添加、删除、重排序PropertySource
         // 设置environment的active profiles
         configureEnvironment(environment, applicationArguments.getSourceArgs());
         //通知environment准备好
         listeners.environmentPrepared(environment);
         bindToSpringApplication(environment);
         if (!this.isCustomEnvironment) {
             environment = new EnvironmentConverter(getClassLoader()).convertEnvironmentIfNecessary(environment,
                     deduceEnvironmentClass());
         }
         ConfigurationPropertySources.attach(environment);
         return environment;
     }
     

   •   //根据推断来的web应用容器类型创建对应的Spring context
       //servlet容器对应的是AnnotationConfigServletWebServerApplicationContext
       context = createApplicationContext();
     

   • prepareContext(context, environment, listeners, applicationArguments, printedBanner);
     准备Spring context

     private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment,
         SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {
         context.setEnvironment(environment);
         postProcessApplicationContext(context);
         // 从Spring factories中加载到的ApplicationContextInitializer对应的实例，
         // 调用对应实例的initialize方法，把Spring context传进去
         applyInitializers(context);
         listeners.contextPrepared(context);
         if (this.logStartupInfo) {
             logStartupInfo(context.getParent() == null);
             logStartupProfileInfo(context);
         }
         // Add boot specific singleton beans
         ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
         beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
         if (printedBanner != null) {
             beanFactory.registerSingleton("springBootBanner", printedBanner);
         }
         if (beanFactory instanceof DefaultListableBeanFactory) {
             ((DefaultListableBeanFactory) beanFactory)
                     .setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
         }
         // Load the sources
         Set