springboot启动主要分两部启动

1. spring容器启动
2. servlet容器启动

• spring容器启动

  @SpringBootApplication
@ServletComponentScan
public class Spdemo01Application {
    public static void main(String[] args) {
                // 核心启动方法run
        SpringApplication.run(Spdemo01Application.class, args);
    }
}

  public ConfigurableApplicationContext run(String... args) {
        // 打点
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        ConfigurableApplicationContext context = null;
        Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList();
        this.configureHeadlessProperty();
        // 收集所有实现SpringApplicationRunListener的子类，在不同生命周期触发
        SpringApplicationRunListeners listeners = this.getRunListeners(args);
       // 启动触发
        listeners.starting();

        Collection exceptionReporters;
        try {
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
            // environment 环境准备
            ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments);
            this.configureIgnoreBeanInfo(environment);
            // 设置banner图
            Banner printedBanner = this.printBanner(environment);
            // springboot创建AnnotationConfigServletWebServerApplicationContext上下文，通过上下 
            // 文对象子类勾子方法实现不同的处理
            context = this.createApplicationContext();
            exceptionReporters = this.getSpringFactoriesInstances(SpringBootExceptionReporter.class, new Class[]{ConfigurableApplicationContext.class}, context);
            // 上下文准备，生命周期，将environment设置到上下文
            this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);
           // spring中的启动spring容器方法，核心方法，执行到此说明spring容器已经启动
            this.refreshContext(context);
            this.afterRefresh(context, applicationArguments);
            stopWatch.stop();
            if (this.logStartupInfo) {
                (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch);
            }

            listeners.started(context);
            this.callRunners(context, applicationArguments);
        } catch (Throwable var10) {
            this.handleRunFailure(context, var10, exceptionReporters, listeners);
            throw new IllegalStateException(var10);
        }

        try {
            listeners.running(context);
            return context;
        } catch (Throwable var9) {
            this.handleRunFailure(context, var9, exceptionReporters, (SpringApplicationRunListeners)null);
            throw new IllegalStateException(var9);
        }
    }

• servlet容器启动
  spring容器启动执行到核心方法refresh（）

 public void refresh() throws BeansException, IllegalStateException {
        synchronized(this.startupShutdownMonitor) {
            this.prepareRefresh();
            ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
            this.prepareBeanFactory(beanFactory);

            try {
                this.postProcessBeanFactory(beanFactory);
                this.invokeBeanFactoryPostProcessors(beanFactory);
                this.registerBeanPostProcessors(beanFactory);
                this.initMessageSource();
                this.initApplicationEventMulticaster();
                // 其他都是正常的启动spring容器方法，这个方法和启动servlet容器的核心勾子方法
                this.onRefresh();
                this.registerListeners();
                this.finishBeanFactoryInitialization(beanFactory);
                this.finishRefresh();
            } catch (BeansException var9) {
                if (this.logger.isWarnEnabled()) {
                    this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
                }

                this.destroyBeans();
                this.cancelRefresh(var9);
                throw var9;
            } finally {
                this.resetCommonCaches();
            }

        }
    }

  在AbstractApplicationContext中的空方法，实现要子类实现，模板设计模式，俗称勾子方法
   protected void onRefresh() throws BeansException {
    }

子类ServletWebServerApplicationContext实现

 protected void onRefresh() {
        super.onRefresh();

        try {
           // 创建webServer
            this.createWebServer();
        } catch (Throwable var2) {
            throw new ApplicationContextException("Unable to start web server", var2);
        }
    }

private void createWebServer() {
        WebServer webServer = this.webServer;
        ServletContext servletContext = this.getServletContext();
        if (webServer == null && servletContext == null) {
            // 工厂模式创建
            ServletWebServerFactory factory = this.getWebServerFactory();
            this.webServer = factory.getWebServer(new ServletContextInitializer[]{this.getSelfInitializer()});
        } else if (servletContext != null) {
            try {
                this.getSelfInitializer().onStartup(servletContext);
            } catch (ServletException var4) {
                throw new ApplicationContextException("Cannot initialize servlet context", var4);
            }
        }

        this.initPropertySources();
    }

    protected ServletWebServerFactory getWebServerFactory() {
        // 工厂对象
        String[] beanNames = this.getBeanFactory().getBeanNamesForType(ServletWebServerFactory.class);
        if (beanNames.length == 0) {
            throw new ApplicationContextException("Unable to start ServletWebServerApplicationContext due to missing ServletWebServerFactory bean.");
        } else if (beanNames.length > 1) {
            throw new ApplicationContextException("Unable to start ServletWebServerApplicationContext due to multiple ServletWebServerFactory beans : " + StringUtils.arrayToCommaDelimitedString(beanNames));
        } else {
            return (ServletWebServerFactory)this.getBeanFactory().getBean(beanNames[0], ServletWebServerFactory.class);
        }
    }

ServletWebServerFactory的实现，通过spi机制选择默认tomcat

1636591004(1).jpg

默认使用tomcat，然后通过代码启动tomcat