SpringBoot 中啓動 Tomcat 流程

前面在一篇文章中介紹了 Spring 中的一些重要的 context。有一些在此文中提到的 context，能夠參看上篇文章。

SpringBoot 項目之因此部署簡單，其很大一部分緣由就是由於不用本身折騰 Tomcat 相關配置，由於其自己內置了各類 Servlet 容器。一直好奇：SpringBoot 是怎麼經過簡單運行一個 main 函數，就能將容器啓動起來，並將自身部署到其上。此文想梳理清楚這個問題。

咱們從SpringBoot的啓動入口中分析：

Context 建立

1// Create, load, refresh and run the ApplicationContext
2context = createApplicationContext();
複製代碼

在SpringBoot 的 run 方法中，咱們發現其中很重要的一步就是上面的一行代碼。註釋也寫的很清楚：

建立、加載、刷新、運行 ApplicationContext。

繼續往裏面走。

 1protected ConfigurableApplicationContext createApplicationContext() {
 2   Class<?> contextClass = this.applicationContextClass;
 3   if (contextClass == null) {
 4      try {
 5         contextClass = Class.forName(this.webEnvironment
 6               ? DEFAULT_WEB_CONTEXT_CLASS : DEFAULT_CONTEXT_CLASS);
 7      }
 8      catch (ClassNotFoundException ex) {
 9         throw new IllegalStateException(
10               "Unable create a default ApplicationContext, "
11                     + "please specify an ApplicationContextClass",
12               ex);
13      }
14   }
15   return (ConfigurableApplicationContext) BeanUtils.instantiate(contextClass);
16}
複製代碼

邏輯很清楚：

先找到 context 類，而後利用工具方法將其實例化。

其中第5行有個判斷：若是是 web 環境，則加載 DEFAULT _WEB_CONTEXT_CLASS類。參當作員變量定義，其類名爲：

1AnnotationConfigEmbeddedWebApplicationContext
複製代碼

此類的繼承結構如圖：

直接繼承 GenericWebApplicationContext。關於該類前文已有介紹，只要記得它是專門爲 web application提供context 的就好。

refresh

在經歷過 Context 的建立以及Context的一些列初始化以後，調用 Context 的 refresh 方法，真正的好戲纔開始上演。

從前面咱們能夠看到AnnotationConfigEmbeddedWebApplicationContext的繼承結構，調用該類的refresh方法，最終會由其直接父類：EmbeddedWebApplicationContext 來執行。

 1@Override
 2protected void onRefresh() {
 3   super.onRefresh();
 4   try {
 5      createEmbeddedServletContainer();
 6   }
 7   catch (Throwable ex) {
 8      throw new ApplicationContextException("Unable to start embedded container",
 9            ex);
10   }
11}
複製代碼

咱們重點看第5行。

 1private void createEmbeddedServletContainer() {
 2   EmbeddedServletContainer localContainer = this.embeddedServletContainer;
 3   ServletContext localServletContext = getServletContext();
 4   if (localContainer == null && localServletContext == null) {
 5      EmbeddedServletContainerFactory containerFactory = getEmbeddedServletContainerFactory();
 6      this.embeddedServletContainer = containerFactory
 7            .getEmbeddedServletContainer(getSelfInitializer());
 8   }
 9   else if (localServletContext != null) {
10      try {
11         getSelfInitializer().onStartup(localServletContext);
12      }
13      catch (ServletException ex) {
14         throw new ApplicationContextException("Cannot initialize servlet context",
15               ex);
16      }
17   }
18   initPropertySources();
19}
複製代碼

代碼第5行，獲取到了一個EmbeddedServletContainerFactory，顧名思義，其做用就是爲了下一步建立一個嵌入式的 servlet 容器：EmbeddedServletContainer。

 1public interface EmbeddedServletContainerFactory {
 2
 3   /**
 4    * 建立一個配置徹底的可是目前還處於「pause」狀態的實例.
 5    * 只有其 start 方法被調用後，Client 才能與其創建鏈接。
 6    */
 7   EmbeddedServletContainer getEmbeddedServletContainer(
 8         ServletContextInitializer... initializers);
 9
10}
複製代碼

第六、7行，在 containerFactory 獲取EmbeddedServletContainer的時候，參數爲 getSelfInitializer 函數的執行結果。暫時無論其內部機制如何，只要知道它會返回一個 ServletContextInitializer 用於容器初始化的對象便可，咱們繼續往下看。

因爲 EmbeddedServletContainerFactory 是個抽象工廠，不一樣的容器有不一樣的實現，由於SpringBoot默認使用Tomcat，因此就以 Tomcat 的工廠實現類 TomcatEmbeddedServletContainerFactory 進行分析：

 1@Override
 2public EmbeddedServletContainer getEmbeddedServletContainer(
 3      ServletContextInitializer... initializers) {
 4   Tomcat tomcat = new Tomcat();
 5   File baseDir = (this.baseDirectory != null ? this.baseDirectory
 6         : createTempDir("tomcat"));
 7   tomcat.setBaseDir(baseDir.getAbsolutePath());
 8   Connector connector = new Connector(this.protocol);
 9   tomcat.getService().addConnector(connector);
10   customizeConnector(connector);
11   tomcat.setConnector(connector);
12   tomcat.getHost().setAutoDeploy(false);
13   tomcat.getEngine().setBackgroundProcessorDelay(-1);
14   for (Connector additionalConnector : this.additionalTomcatConnectors) {
15      tomcat.getService().addConnector(additionalConnector);
16   }
17   prepareContext(tomcat.getHost(), initializers);
18   return getTomcatEmbeddedServletContainer(tomcat);
19}
複製代碼

從第8行一直到第16行完成了 tomcat 的 connector 的添加。tomcat 中的 connector 主要負責用來處理 http 請求，具體原理能夠參看 Tomcat 的源碼，此處暫且不提。

第17行的 方法有點長，重點看其中的幾行：

 1if (isRegisterDefaultServlet()) {
 2   addDefaultServlet(context);
 3}
 4if (isRegisterJspServlet() && ClassUtils.isPresent(getJspServletClassName(),
 5      getClass().getClassLoader())) {
 6   addJspServlet(context);
 7   addJasperInitializer(context);
 8   context.addLifecycleListener(new StoreMergedWebXmlListener());
 9}
10ServletContextInitializer[] initializersToUse = mergeInitializers(initializers);
11configureContext(context, initializersToUse);
複製代碼

前面兩個分支判斷添加了默認的 servlet類和與 jsp 相關的 servlet 類。

對全部的 ServletContextInitializer 進行合併後，利用合併後的初始化類對 context 進行配置。

第 18 行，順着方法一直往下走，開始正式啓動 Tomcat。

 1private synchronized void initialize() throws EmbeddedServletContainerException {
 2   TomcatEmbeddedServletContainer.logger
 3         .info("Tomcat initialized with port(s): " + getPortsDescription(false));
 4   try {
 5      addInstanceIdToEngineName();
 6
 7      // Remove service connectors to that protocol binding doesn't happen yet
 8      removeServiceConnectors();
 9
10      // Start the server to trigger initialization listeners
11      this.tomcat.start();
12
13      // We can re-throw failure exception directly in the main thread
14      rethrowDeferredStartupExceptions();
15
16      // Unlike Jetty, all Tomcat threads are daemon threads. We create a
17      // blocking non-daemon to stop immediate shutdown
18      startDaemonAwaitThread();
19   }
20   catch (Exception ex) {
21      throw new EmbeddedServletContainerException("Unable to start embedded Tomcat",
22            ex);
23   }
24}
複製代碼

第11行正式啓動 tomcat。

如今咱們回過來看看以前的那個 getSelfInitializer 方法：

1private ServletContextInitializer getSelfInitializer() {
2   return new ServletContextInitializer() {
3      @Override
4      public void onStartup(ServletContext servletContext) throws ServletException {
5         selfInitialize(servletContext);
6      }
7   };
8}
複製代碼

 1private void selfInitialize(ServletContext servletContext) throws ServletException {
 2   prepareEmbeddedWebApplicationContext(servletContext);
 3   ConfigurableListableBeanFactory beanFactory = getBeanFactory();
 4   ExistingWebApplicationScopes existingScopes = new ExistingWebApplicationScopes(
 5         beanFactory);
 6   WebApplicationContextUtils.registerWebApplicationScopes(beanFactory,
 7         getServletContext());
 8   existingScopes.restore();
 9   WebApplicationContextUtils.registerEnvironmentBeans(beanFactory,
10         getServletContext());
11   for (ServletContextInitializer beans : getServletContextInitializerBeans()) {
12      beans.onStartup(servletContext);
13   }
14}
複製代碼

在第2行的prepareEmbeddedWebApplicationContext方法中主要是將 EmbeddedWebApplicationContext 設置爲rootContext。

第4行容許用戶存儲自定義的 scope。

第6行主要是用來將web專用的scope註冊到BeanFactory中，好比("request", "session", "globalSession", "application")。

第9行註冊web專用的environment bean（好比 ("contextParameters", "contextAttributes"））到給定的 BeanFactory 中。

第11和12行，比較重要，主要用來配置 servlet、filters、listeners、context-param和一些初始化時的必要屬性。

以其一個實現類ServletContextInitializer試舉一例：

 1@Override
 2public void onStartup(ServletContext servletContext) throws ServletException {
 3   Assert.notNull(this.servlet, "Servlet must not be null");
 4   String name = getServletName();
 5   if (!isEnabled()) {
 6      logger.info("Servlet " + name + " was not registered (disabled)");
 7      return;
 8   }
 9   logger.info("Mapping servlet: '" + name + "' to " + this.urlMappings);
10   Dynamic added = servletContext.addServlet(name, this.servlet);
11   if (added == null) {
12      logger.info("Servlet " + name + " was not registered "
13            + "(possibly already registered?)");
14      return;
15   }
16   configure(added);
17}
複製代碼

能夠看第9行的打印：正是在這裏實現了 servlet 到 URLMapping的映射。

總結

這篇文章從主幹脈絡分析找到了爲何在SpringBoot中不用本身配置Tomcat，內置的容器是怎麼啓動起來的，順便在分析的過程當中找到了咱們經常使用的 urlMapping 映射 Servlet 的實現。