Tomcat 是如何启动的

run 方法
总结下步骤为 > 1. 配置属性 > 2. 获取监听器，发布应用开始启动事件 > 3. 初始化输入参数 > 4. 配置环境，输出 banner > 5. 创建上下文 > 6. 预处理上下文 > 7. 刷新上下文 > 8. 再刷新上下文 > 9. 发布应用已经启动事件 > 10. 发布应用启动完成事件

  1. public ConfigurableApplicationContext run(String... args) {
  2.     StopWatch stopWatch = new StopWatch();
  3.     stopWatch.start();
  4.     ConfigurableApplicationContext context = null;
  5.     Collection<springbootexceptionreporter> exceptionReporters = new ArrayList<>();
  7.     //设置系统属性『java.awt.headless』，为true则启用headless模式支持
  8.     configureHeadlessProperty();
  10.     //通过*SpringFactoriesLoader*检索*META-INF/spring.factories*，
  11.        //找到声明的所有SpringApplicationRunListener的实现类并将其实例化，
  12.        //之后逐个调用其started()方法，广播SpringBoot要开始执行了
  13.     SpringApplicationRunListeners listeners = getRunListeners(args);
  15.     //发布应用开始启动事件
  16.     listeners.starting();
  17.     try {
  19.     //初始化参数
  20.       ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
  22.       //创建并配置当前SpringBoot应用将要使用的Environment（包括配置要使用的PropertySource以及Profile）,
  23.         //并遍历调用所有的SpringApplicationRunListener的environmentPrepared()方法，广播Environment准备完毕。
  24.       ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
  25.       configureIgnoreBeanInfo(environment);
  27.       //打印banner
  28.       Banner printedBanner = printBanner(environment);
  30.       //创建应用上下文
  31.       ==============
  32.       context = createApplicationContext();
  33.       ==============
  35.       //通过*SpringFactoriesLoader*检索*META-INF/spring.factories*，获取并实例化异常分析器
  36.       exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
  37.           new Class[] { ConfigurableApplicationContext.class }, context);
  39.       //为ApplicationContext加载environment，之后逐个执行ApplicationContextInitializer的initialize()方法来进一步封装ApplicationContext，
  40.         //并调用所有的SpringApplicationRunListener的contextPrepared()方法，【EventPublishingRunListener只提供了一个空的contextPrepared()方法】，
  41.         //之后初始化IoC容器，并调用SpringApplicationRunListener的contextLoaded()方法，广播ApplicationContext的IoC加载完成，
  42.         //这里就包括通过**@EnableAutoConfiguration**导入的各种自动配置类。
  43.       prepareContext(context, environment, listeners, applicationArguments, printedBanner);
  45.       //刷新上下文
  46.       ==============
  47.       refreshContext(context);
  48.       ============== 
  50.       //再一次刷新上下文,其实是空方法，可能是为了后续扩展。
  51.       afterRefresh(context, applicationArguments);
  53.       stopWatch.stop();
  54.       if (this.logStartupInfo) {
  55.         new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
  56.       }
  57.       //发布应用已经启动的事件
  58.       listeners.started(context);
  59.       //遍历所有注册的ApplicationRunner和CommandLineRunner，并执行其run()方法。
  60.         //我们可以实现自己的ApplicationRunner或者CommandLineRunner，来对SpringBoot的启动过程进行扩展。
  61.       callRunners(context, applicationArguments);
  62.     } catch (Throwable ex) {
  63.       handleRunFailure(context, ex, exceptionReporters, listeners);
  64.       thrownew IllegalStateException(ex);
  65.     }
  67.     try {
  68.     //应用已经启动完成的监听事件
  69.       listeners.running(context);
  70.     } catch (Throwable ex) {
  71.       handleRunFailure(context, ex, exceptionReporters, null);
  72.       thrownew IllegalStateException(ex);
  73.     }
  74.     return context;
  75.   }

其实上面这段代码，如果只要分析 tomcat 内容的话，只需要关注两个内容即可，上下文是如何创建的，上下文是如何刷新的，分别对应的方法就是 createApplicationContext() 和 refreshContext(context)，接下来我们来看看这两个方法做了什么。

创建上下文

这里就是根据我们的 webApplicationType 来判断创建哪种类型的 Servlet,代码中分别对应着 Web 类型(SERVLET),响应式 Web 类型（REACTIVE),非 Web 类型（default),我们建立的是 Web 类型，所以肯定实例化 DEFAULT_SERVLET_WEB_CONTEXT_CLASS 指定的类，也就是 AnnotationConfigServletWebServerApplicationContext 类

刷新上下文

这里还是直接传递调用本类的 refresh(context)方法，最后是强转成父类 AbstractApplicationContext 调用其 refresh()方法

  1. // 类：AbstractApplicationContext
  2. public void refresh() throws BeansException, IllegalStateException {
  3.     synchronized (this.startupShutdownMonitor) {
  4.       // Prepare this context for refreshing.
  5.       prepareRefresh();
  7.       // Tell the subclass to refresh the internal bean factory.
  8.       ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
  10.       // Prepare the bean factory for use in this context.
  11.       prepareBeanFactory(beanFactory);
  13.       try {
  14.         // Allows post-processing of the bean factory in context subclasses.
  15.         postProcessBeanFactory(beanFactory);
  17.         // Invoke factory processors registered as beans in the context.
  18.         invokeBeanFactoryPostProcessors(beanFactory);
  20.         // Register bean processors that intercept bean creation.
  21.         registerBeanPostProcessors(beanFactory);
  23.         // Initialize message source for this context.
  24.         initMessageSource();
  26.         // Initialize event multicaster for this context.
  27.         initApplicationEventMulticaster();
  29.         // 在特定上下文子类中初始化其他特殊bean。这里的意思就是调用各个子类的onRefresh()
  30.         ============
  31.         onRefresh();
  32.         ============
  34.         // Check for listener beans and register them.
  35.         registerListeners();
  37.         // Instantiate all remaining (non-lazy-init) singletons.
  38.         finishBeanFactoryInitialization(beanFactory);
  40.         // Last step: publish corresponding event.
  41.         finishRefresh();
  42.       }
  44.       catch (BeansException ex) {
  45.         if (logger.isWarnEnabled()) {
  46.           logger.warn("Exception encountered during context initialization - " +
  47.               "cancelling refresh attempt: " + ex);
  48.         }
  50.         // Destroy already created singletons to avoid dangling resources.
  51.         destroyBeans();
  53.         // Reset 'active' flag.
  54.         cancelRefresh(ex);
  56.         // Propagate exception to caller.
  57.         throw ex;
  58.       }
  60.       finally {
  61.         // Reset common introspection caches in Spring's core, since we
  62.         // might not ever need metadata for singleton beans anymore...
  63.         resetCommonCaches();
  64.       }
  65.     }
  66.   }

这里我们看到 onRefresh()方法是调用其子类的实现，根据我们上文的分析，我们这里的子类是 ServletWebServerApplicationContext。
到这里，其实庐山真面目已经出来了，createWebServer()就是启动 web 服务，但是还没有真正启动 Tomcat，既然 webServer 是通过 ServletWebServerFactory 工厂来获取的。
其中 Tomcat 启动为:
TomcatServletWebServerFactory.getWebServer()