SpringBoot源码分析之SpringBoot的启动过程

先看示例

SpringBoot的启动很简单，在许多情况下，你可以委托给静态SpringApplication.run方法，代码如下：

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

从代码上可以看出，调用了SpringApplication的静态方法run。这个run方法会构造一个SpringApplication的实例，然后再调用这里实例的run方法就表示启动SpringBoot。

当你的应用程序启动时，你应该看到类似于以下输出的内容:

  .   ____          _            __ _ _
 /\ / ___'_ __ _ _(_)_ __  __ _    
( ( )\___ | '_ | '_| | '_ / _` |    
 \/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::       (v1.5.10.RELEASE)

因此，想要分析SpringBoot的启动过程，我们需要熟悉SpringApplication的构造过程以及SpringApplication的run方法执行过程即可。

我们以上述这段代码为例，分析SpringBoot的启动过程。

一、SpringApplication的构造过程

SpringApplication构造的时候内部会调用一个private方法initialize：

    public SpringApplication(Object... sources) {
      initialize(sources); // sources目前是一个MyApplication的class对象
    }

    private void initialize(Object[] sources) {
      if (sources != null && sources.length > 0) {
        this.sources.addAll(Arrays.asList(sources)); // 把sources设置到SpringApplication的sources属性中，目前只是一个MyApplication类对象
      }
      this.webEnvironment = deduceWebEnvironment(); // 判断是否是web程序，如果(javax.servlet.Servlet和org.springframework.web.context.ConfigurableWebApplicationContext）都在当前的类加载器中，则为true否则为false，判断结果设置到webEnvironment属性中
      

      // 从spring.factories文件中找出key为ApplicationContextInitializer的类并实例化后设置到SpringApplication的initializers属性中。这个过程也就是找出所有的应用程序初始化器
      setInitializers((Collection) getSpringFactoriesInstances(
          ApplicationContextInitializer.class));

      // 从spring.factories文件中找出key为ApplicationListener的类并实例化后设置到SpringApplication的listeners属性中。这个过程就是找出所有的应用程序事件监听器
      setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
      // 找出main类，这里是MyApplication类
      this.mainApplicationClass = deduceMainApplicationClass();
    }

下面分别介绍下载SpringApplication的构造中，涉及到的几个类：

1.1、ApplicationContextInitializer，应用程序初始化器，做一些初始化的工作：

    public interface ApplicationContextInitializer<C extends ConfigurableApplicationContext> {
        void initialize(C applicationContext);
    }

Springboot中目前有如下这些ContextInitializer，看截图：

       

1.2、ApplicationListener，应用程序事件(ApplicationEvent)监听器：

    public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {
        void onApplicationEvent(E event);
    }

这里的应用程序事件(ApplicationEvent)有：应用程序启动事件(ApplicationStartedEvent)、失败事件(ApplicationFailedEvent)、准备事件(ApplicationPreparedEvent)等。

应用程序事件监听器跟监听事件是绑定的。比如：

• ConfigServerBootstrapApplicationListener只跟ApplicationEnvironmentPreparedEvent事件绑定，
• LiquibaseServiceLocatorApplicationListener只跟ApplicationStartedEvent事件绑定，
• LoggingApplicationListener跟所有事件绑定等。

默认情况下，initialize方法从spring.factories文件中找出的key为ApplicationContextInitializer的类有：

org.springframework.boot.context.config.DelegatingApplicationContextInitializer
org.springframework.boot.context.ContextIdApplicationContextInitializer
org.springframework.boot.context.ConfigurationWarningsApplicationContextInitializer
org.springframework.boot.context.web.ServerPortInfoApplicationContextInitializer
org.springframework.boot.autoconfigure.logging.AutoConfigurationReportLoggingInitializer

key为ApplicationListener的有：

org.springframework.boot.context.config.ConfigFileApplicationListener
org.springframework.boot.context.config.AnsiOutputApplicationListener
org.springframework.boot.logging.LoggingApplicationListener
org.springframework.boot.logging.ClasspathLoggingApplicationListener
org.springframework.boot.autoconfigure.BackgroundPreinitializer
org.springframework.boot.context.config.DelegatingApplicationListener
org.springframework.boot.builder.ParentContextCloserApplicationListener
org.springframework.boot.context.FileEncodingApplicationListener
org.springframework.boot.liquibase.LiquibaseServiceLocatorApplicationListener

二、SpringApplication的执行

SpringApplication的run方法代码如下：

public ConfigurableApplicationContext run(String... args) {
        //①开启任务执行时间监听器
        StopWatch stopWatch = new StopWatch();
        // 开始执行，记录开始时间
        stopWatch.start();
        
        ConfigurableApplicationContext context = null;
        FailureAnalyzers analyzers = null;
        
        //设置系统属性『java.awt.headless』，为true则启用headless模式支持
        configureHeadlessProperty();
        
        //②通过*SpringFactoriesLoader*检索*META-INF/spring.factories*，
        //找到声明的所有SpringApplicationRunListener的实现类并将其实例化，
        //之后逐个调用其started()方法，广播SpringBoot要开始执行了。
        SpringApplicationRunListeners listeners = getRunListeners(args);
        //相当于批量的发布事件，及批量的监听器处理事件进行相应的操作
        listeners.starting();
        
        try {
            //构造一个应用程序参数持有类
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(
                    args);
            
            //③创建并配置当前SpringBoot应用将要使用的Environment（包括配置要使用的PropertySource以及Profile）,
            //并遍历调用所有的SpringApplicationRunListener的environmentPrepared()方法，广播Environment准备完毕。
            ConfigurableEnvironment environment = prepareEnvironment(listeners,
                    applicationArguments);
            
            //④决定是否打印Banner
            Banner printedBanner = printBanner(environment);
            
            //⑤根据webEnvironment的值来决定创建何种类型的ApplicationContext对象
            //如果是web环境，则创建org.springframework.boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext
            //否则创建org.springframework.context.annotation.AnnotationConfigApplicationContext
            context = createApplicationContext();
            
            //⑥-1注册异常分析器
            analyzers = new FailureAnalyzers(context);
            
            //⑥-2为ApplicationContext加载environment，之后逐个执行ApplicationContextInitializer的initialize()方法来进一步封装ApplicationContext，
            //并调用所有的SpringApplicationRunListener的contextPrepared()方法，【EventPublishingRunListener只提供了一个空的contextPrepared()方法】，
            //之后初始化IoC容器，并调用SpringApplicationRunListener的contextLoaded()方法，广播ApplicationContext的IoC加载完成，
            //这里就包括通过**@EnableAutoConfiguration**导入的各种自动配置类。
            prepareContext(context, environment, listeners, applicationArguments,
                    printedBanner);
                    
            //⑦初始化所有自动配置类，调用ApplicationContext的refresh()方法        
            refreshContext(context);
            
            //⑧遍历所有注册的ApplicationRunner和CommandLineRunner，并执行其run()方法。
            //该过程可以理解为是SpringBoot完成ApplicationContext初始化前的最后一步工作，
            //我们可以实现自己的ApplicationRunner或者CommandLineRunner，来对SpringBoot的启动过程进行扩展。
            afterRefresh(context, applicationArguments);
            
            //⑨调用所有的SpringApplicationRunListener的finished()方法，广播SpringBoot已经完成了ApplicationContext初始化的全部过程。
            listeners.finished(context, null);
            
            //⑩关闭任务执行时间监听器
            stopWatch.stop();
            
            //⑪如果开启日志，则打印执行是时间

            if (this.logStartupInfo) {
                new StartupInfoLogger(this.mainApplicationClass)
                        .logStarted(getApplicationLog(), stopWatch);
            }
            return context;
        }
        catch (Throwable ex) {
            //⑫调用异常分析器打印报告，调用所有的SpringApplicationRunListener的finished()方法将异常信息发布出去

            handleRunFailure(context, listeners, analyzers, ex);
            throw new IllegalStateException(ex);
        }
    }

相关的分析：

①StopWatch，StopWatch相关见《Spring计时器StopWatch使用》

分析run方法之前，先看一下SpringApplication中的一些事件和监听器概念。

②、首先是SpringApplicationRunListeners类和SpringApplicationRunListener类的介绍

• SpringApplicationRunListeners类：

  SpringApplicationRunListeners内部持有SpringApplicationRunListener集合和1个Log日志类。用于SpringApplicationRunListener监听器的批量执行。

class SpringApplicationRunListeners {

    private final Log log;

    private final List<SpringApplicationRunListener> listeners;

• SpringApplicationRunListener类：

　　　　SpringApplicationRunListener看名字也知道用于监听SpringApplication的run方法的执行。

              

　　　　它定义了5个步骤：

1. 1. 　　started(run方法执行的时候立马执行；对应事件的类型是ApplicationStartedEvent)：通知监听器，SpringBoot开始执行
   2. 　　environmentPrepared(ApplicationContext创建之前并且环境信息准备好的时候调用；对应事件的类型是ApplicationEnvironmentPreparedEvent)：通知监听器，Environment准备完成
   3. 　　contextPrepared(ApplicationContext创建好并且在source加载之前调用一次；没有具体的对应事件)：通知监听器，ApplicationContext已经创建并初始化完成
   4. 　　contextLoaded(ApplicationContext创建并加载之后并在refresh之前调用；对应事件的类型是ApplicationPreparedEvent)：通知监听器，ApplicationContext已经完成IoC配置价值
   5. 　　finished(run方法结束之前调用；对应事件的类型是ApplicationReadyEvent或ApplicationFailedEvent)：通知监听器，SpringBoot启动完成

　　　　　　　　SpringApplicationRunListener目前只有一个实现类EventPublishingRunListener，它把监听的过程封装成了SpringApplicationEvent事件并让内部属性(属性名为multicaster)ApplicationEventMulticaster接口的实现类SimpleApplicationEventMulticaster广播出去，广播出去的事件对象会被SpringApplication中的listeners属性进行处理。

所以说SpringApplicationRunListener和ApplicationListener之间的关系是通过ApplicationEventMulticaster广播出去的SpringApplicationEvent所联系起来的。更多的spring事件知识见《ApplicationEvent事件机制源码分析》

 

③、SpringBoot的Environment的准备

    private ConfigurableEnvironment prepareEnvironment(
            SpringApplicationRunListeners listeners,
            ApplicationArguments applicationArguments) {
        // 创建SpringBoot的Environment，可能是StandardServletEnvironment或者StandardEnvironment
        ConfigurableEnvironment environment = getOrCreateEnvironment();
        //包括配置要使用的PropertySource以及Profile
        configureEnvironment(environment, applicationArguments.getSourceArgs());
        //遍历调用所有的Environment的environmentPrepared方法，目前只有一个实现类EventPublishRunListener，即调用其multicastEvent，广播事件
        listeners.environmentPrepared(environment);
        if (!this.webEnvironment) {
            //将给定环境转换为标准环境。如果环境已经是一个标准环境，而不是ConfigurableWebEnvironment，则不执行转换，并且不改变返回值。
            environment = new EnvironmentConverter(getClassLoader())
                    .convertToStandardEnvironmentIfNecessary(environment);
        }
        return environment;
    }

④决定是否打印Banner

    private Banner printBanner(ConfigurableEnvironment environment) {
        //判断是否开启打印,如果没有开启，直接返回不执行下面的打印逻辑
        if (this.bannerMode == Banner.Mode.OFF) {
            return null;
        }
        //读取banner文件
        ResourceLoader resourceLoader = this.resourceLoader != null ? this.resourceLoader
                : new DefaultResourceLoader(getClassLoader());
        SpringApplicationBannerPrinter bannerPrinter = new SpringApplicationBannerPrinter(
                resourceLoader, this.banner);
        if (this.bannerMode == Mode.LOG) {
            return bannerPrinter.print(environment, this.mainApplicationClass, logger);
        }
        return bannerPrinter.print(environment, this.mainApplicationClass, System.out);
    }

⑤创建ApplicationContext

    protected ConfigurableApplicationContext createApplicationContext() {
        Class<?> contextClass = this.applicationContextClass;
        if (contextClass == null) {
            try {
                //通过反射获得ApplicationContext的类信息

　　　　　　　　// 如果是web程序，那么构造org.springframework.boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext容器
          　　// 否则构造org.springframework.context.annotation.AnnotationConfigApplicationContext容器

                contextClass = Class.forName(this.webEnvironment
                        ? DEFAULT_WEB_CONTEXT_CLASS : DEFAULT_CONTEXT_CLASS);
            }
            catch (ClassNotFoundException ex) {
                throw new IllegalStateException(
                        "Unable create a default ApplicationContext, "
                                + "please specify an ApplicationContextClass",
                        ex);
            }
        }
        //通过类的newInstance创建实例
        return (ConfigurableApplicationContext) BeanUtils.instantiate(contextClass);
    }

    public static <T> T instantiate(Class<T> clazz) throws BeanInstantiationException {
        Assert.notNull(clazz, "Class must not be null");
        if (clazz.isInterface()) {
            throw new BeanInstantiationException(clazz, "Specified class is an interface");
        }
        try {
            return clazz.newInstance();
        }
        catch (InstantiationException ex) {
            throw new BeanInstantiationException(clazz, "Is it an abstract class?", ex);
        }
        catch (IllegalAccessException ex) {
            throw new BeanInstantiationException(clazz, "Is the constructor accessible?", ex);
        }
    }

⑥-1、注册异常分析器

    public FailureAnalyzers(ConfigurableApplicationContext context) {
        this(context, null);
    }

    FailureAnalyzers(ConfigurableApplicationContext context, ClassLoader classLoader) {
        Assert.notNull(context, "Context must not be null");
        this.classLoader = (classLoader == null ? context.getClassLoader() : classLoader);
        //通过反射，批量创建FailureAnalyzer,顺序的放到list集合里
        this.analyzers = loadFailureAnalyzers(this.classLoader);
        prepareFailureAnalyzers(this.analyzers, context);
    }

    //遍历为每个FailureAnalyzer调用prepareAnalyzer
    private void prepareFailureAnalyzers(List<FailureAnalyzer> analyzers,
            ConfigurableApplicationContext context) {
        for (FailureAnalyzer analyzer : analyzers) {
            prepareAnalyzer(context, analyzer);
        }
    }
    //将Analyzer拥有的工厂赋值给上面新创建的Analyzer，提供给Analyzer实例的回调。
    //在填充普通bean属性之后调用，但在初始化回调(如InitializingBean.afterPropertiesSet()或自定义init-method)之前调用。
    private void prepareAnalyzer(ConfigurableApplicationContext context,
            FailureAnalyzer analyzer) {
        if (analyzer instanceof BeanFactoryAware) {
            ((BeanFactoryAware) analyzer).setBeanFactory(context.getBeanFactory());
        }
    }

⑥-2、ApplicationContext的初始化（environment、initializer）

    private void prepareContext(ConfigurableApplicationContext context,
            ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
            ApplicationArguments applicationArguments, Banner printedBanner) {
        //为context设置上面的Environment
        context.setEnvironment(environment);
        
        //在ApplicationContext中应用任何相关的后处理。子类可以根据需要应用额外的处理。
        postProcessApplicationContext(context);
        
        //在刷新上下文之前，将所有的applicationcontextinitialalizer应用于上下文。这里是遍历执行所有的initialize()来进一步封装ApplicationContext
        applyInitializers(context);
        
        //
        listeners.contextPrepared(context);
        if (this.logStartupInfo) {
            logStartupInfo(context.getParent() == null);
            logStartupProfileInfo(context);
        }

        // Add boot specific singleton beans
        context.getBeanFactory().registerSingleton("springApplicationArguments",
                applicationArguments);
        if (printedBanner != null) {
            context.getBeanFactory().registerSingleton("springBootBanner", printedBanner);
        }

        // Load the sources
        Set<Object> sources = getSources();
        Assert.notEmpty(sources, "Sources must not be empty");
        load(context, sources.toArray(new Object[sources.size()]));
        
        //调用SpringApplicationRunListener的contextLoaded()方法，广播ApplicationContext的IoC加载完成
        listeners.contextLoaded(context);
    }
    
    //初始化器做的工作，比如ContextIdApplicationContextInitializer会设置应用程序的id；AutoConfigurationReportLoggingInitializer会给应用程序添加一个条件注解解析器报告等：
    //在刷新上下文之前，将所有的applicationcontextinitialalizer应用于上下文。
    protected void applyInitializers(ConfigurableApplicationContext context) {
        for (ApplicationContextInitializer initializer : getInitializers()) {
            Class<?> requiredType = GenericTypeResolver.resolveTypeArgument(
                    initializer.getClass(), ApplicationContextInitializer.class);
            Assert.isInstanceOf(requiredType, context, "Unable to call initializer.");
            initializer.initialize(context);
        }
    }

⑦refreshContext

Spring容器的刷新refresh方法内部会做很多很多的事情：比如BeanFactory的设置，BeanFactoryPostProcessor接口的执行、BeanPostProcessor接口的执行、自动化配置类的解析、条件注解的解析、国际化的初始化等等。这部分内容会在之后的文章中进行讲解。

    private void refreshContext(ConfigurableApplicationContext context) {
        //刷新底层应用程序上下文
        refresh(context);
        
        //增加钩子
        if (this.registerShutdownHook) {
            try {
                context.registerShutdownHook();
            }
            catch (AccessControlException ex) {
                // Not allowed in some environments.
            }
        }
    }
    
    //刷新底层应用程序上下文
    protected void refresh(ApplicationContext applicationContext) {
        Assert.isInstanceOf(AbstractApplicationContext.class, applicationContext);
        ((AbstractApplicationContext) applicationContext).refresh();
    }

⑧遍历所有注册的ApplicationRunner和CommandLineRunner，并执行其run()方法

   protected void afterRefresh(ConfigurableApplicationContext context,
            ApplicationArguments args) {
        callRunners(context, args);
    }
    
    private void callRunners(ApplicationContext context, ApplicationArguments args) {
        List<Object> runners = new ArrayList<Object>();
        // 找出Spring容器中ApplicationRunner接口的实现类
        runners.addAll(context.getBeansOfType(ApplicationRunner.class).values());
        // 找出Spring容器中CommandLineRunner接口的实现类
        runners.addAll(context.getBeansOfType(CommandLineRunner.class).values());
        // 对runners进行排序
        AnnotationAwareOrderComparator.sort(runners);
        // 遍历runners依次执行
        for (Object runner : new LinkedHashSet<Object>(runners)) {
            // 如果是ApplicationRunner，进行ApplicationRunner的run方法调用
            if (runner instanceof ApplicationRunner) {
                callRunner((ApplicationRunner) runner, args);
            }
            // 如果是CommandLineRunner，进行CommandLineRunner的run方法调用
            if (runner instanceof CommandLineRunner) {
                callRunner((CommandLineRunner) runner, args);
            }
        }
    }

⑨调用所有的SpringApplicationRunListener的finished()方法，广播SpringBoot已经完成了ApplicationContext初始化的全部过程

    public void finished(ConfigurableApplicationContext context, Throwable exception) {
        for (SpringApplicationRunListener listener : this.listeners) {
            callFinishedListener(listener, context, exception);
        }
    }
    
    private void callFinishedListener(SpringApplicationRunListener listener,
            ConfigurableApplicationContext context, Throwable exception) {
        try {
            listener.finished(context, exception);
        }
        catch (Throwable ex) {
            if (exception == null) {
                ReflectionUtils.rethrowRuntimeException(ex);
            }
            if (this.log.isDebugEnabled()) {
                this.log.error("Error handling failed", ex);
            }
            else {
                String message = ex.getMessage();
                message = (message == null ? "no error message" : message);
                this.log.warn("Error handling failed (" + message + ")");
            }
        }
    }
    
    @Override
    public void finished(ConfigurableApplicationContext context, Throwable exception) {
        //创建springboot初始化完成事件
        SpringApplicationEvent event = getFinishedEvent(context, exception);
        if (context != null && context.isActive()) {
            //活动上下文
            context.publishEvent(event);
        }
        else {
            //非活动上下文没有多播程序，直接使用initialMulticaster进行广播
            if (context instanceof AbstractApplicationContext) {
                for (ApplicationListener<?> listener : ((AbstractApplicationContext) context)
                        .getApplicationListeners()) {
                    this.initialMulticaster.addApplicationListener(listener);
                }
            }
            if (event instanceof ApplicationFailedEvent) {
                this.initialMulticaster.setErrorHandler(new LoggingErrorHandler());
            }
            this.initialMulticaster.multicastEvent(event);
        }
    }
    
    private SpringApplicationEvent getFinishedEvent(
            ConfigurableApplicationContext context, Throwable exception) {
        //如果出错了，返回ApplicationFailedEvent的事件
        if (exception != null) {
            return new ApplicationFailedEvent(this.application, this.args, context,
                    exception);
        }
        return new ApplicationReadyEvent(this.application, this.args, context);
    }

⑫调用异常分析器打印报告，调用所有的SpringApplicationRunListener的finished()方法将异常信息发布出去

    private void handleRunFailure(ConfigurableApplicationContext context,
            SpringApplicationRunListeners listeners, FailureAnalyzers analyzers,
            Throwable exception) {
        try {
            try {
                handleExitCode(context, exception);
                listeners.finished(context, exception);
            }
            finally {
                reportFailure(analyzers, exception);
                if (context != null) {
                    context.close();
                }
            }
        }
        catch (Exception ex) {
            logger.warn("Unable to close ApplicationContext", ex);
        }
        ReflectionUtils.rethrowRuntimeException(exception);
    }
    
    private void handleExitCode(ConfigurableApplicationContext context,
            Throwable exception) {
        //根据Exception得到退出码
        int exitCode = getExitCodeFromException(context, exception);
        
        //如果exitCode不为0，发布ExitCodeEvent事件
        if (exitCode != 0) {
            if (context != null) {
                context.publishEvent(new ExitCodeEvent(context, exitCode));
            }
            SpringBootExceptionHandler handler = getSpringBootExceptionHandler();
            if (handler != null) {
                handler.registerExitCode(exitCode);
            }
        }
    }

这样run方法执行完成之后。Spring容器也已经初始化完成，各种监听器和初始化器也做了相应的工作。

总结

• SpringBoot的启动过程，实际上就是对ApplicationContext的初始化过程。

• ApplicationContext创建后立刻为其设置Environment，并由ApplicationContextInitializer对其进一步封装。

• 通过SpringApplicationRunListener在ApplicationContext初始化过程中各个时点发布各种广播事件，并由ApplicationListener负责接收广播事件。

• 初始化过程中完成IoC的注入，包括通过@EnableAutoConfiguration导入的各种自动配置类。

• 初始化完成前调用ApplicationRunner和CommandLineRunner的实现类。

SpringBoot启动的时候，不论调用什么方法，都会构造一个SpringApplication的实例，然后调用这个实例的run方法，这样就表示启动SpringBoot。

在run方法调用之前，也就是构造SpringApplication的时候会进行初始化的工作，初始化的时候会做以下几件事：

1. 把参数sources设置到SpringApplication属性中，这个sources可以是任何类型的参数。本文的例子中这个sources就是MyApplication的class对象
2. 判断是否是web程序，并设置到webEnvironment这个boolean属性中
3. 找出所有的初始化器，默认有5个，设置到initializers属性中
4. 找出所有的应用程序监听器，默认有9个，设置到listeners属性中
5. 找出运行的主类(main class)

SpringApplication构造完成之后调用run方法，启动SpringApplication，run方法执行的时候会做以下几件事：

1. 构造一个StopWatch，观察SpringApplication的执行
2. 找出所有的SpringApplicationRunListener并封装到SpringApplicationRunListeners中，用于监听run方法的执行。监听的过程中会封装成事件并广播出去让初始化过程中产生的应用程序监听器进行监听
3. 构造Spring容器(ApplicationContext)，并返回
   3.1 创建Spring容器的判断是否是web环境，是的话构造AnnotationConfigEmbeddedWebApplicationContext，否则构造AnnotationConfigApplicationContext
   3.2 初始化过程中产生的初始化器在这个时候开始工作
   3.3 Spring容器的刷新(完成bean的解析、各种processor接口的执行、条件注解的解析等等)
4. 从Spring容器中找出ApplicationRunner和CommandLineRunner接口的实现类并排序后依次执行

例子

写了一个例子用来验证分析的启动逻辑，包括自定义的初始化器、监听器、ApplicationRunner和CommandLineRunner。

地址在：https://github.com/fangjian0423/springboot-analysis/tree/master/springboot-startup