基於源碼看Tomcat 在 SpringBoot 中的啟動

前言

我們知道 SpringBoot 給我們帶來了一個全新的開發體驗，我們可以直接把 web 程序達成 jar 包，直接啟動，這就得益於 SpringBoot 內置了容器，可以直接啟動，本文將以 Tomcat 為例，來看看 SpringBoot 是如何啟動 Tomcat 的，同時也將展開學習下 Tomcat 的源碼，瞭解 Tomcat 的設計。

Main 方法說起

用過 SpringBoot 的人都知道，首先要寫一個 main 方法來啟動

<code>@SpringBootApplicationpublicclass TomcatdebugApplication {    public static void main(String[] args) {        SpringApplication.run(TomcatdebugApplication.class, args);    }}/<code>

我們直接點擊 run 方法的源碼，跟蹤下來，發下最終的 run 方法是調用 ConfigurableApplicationContext 方法，源碼如下：

<code>public ConfigurableApplicationContext run(String... args) {    StopWatch stopWatch = new StopWatch();    stopWatch.start();    ConfigurableApplicationContext context = null;    CollectionexceptionReporters = new ArrayList<>();    //設置系統屬性『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);      configureIgnoreBeanInfo(environment);      //打印banner      Banner printedBanner = printBanner(environment);      //創建應用上下文      context = createApplicationContext();      //通過*SpringFactoriesLoader*檢索*META-INF/spring.factories*，獲取並實例化異常分析器      exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,          new Class[] { ConfigurableApplicationContext.class }, context);      //為ApplicationContext加載environment，之後逐個執行ApplicationContextInitializer的initialize()方法來進一步封裝ApplicationContext，        //並調用所有的SpringApplicationRunListener的contextPrepared()方法，【EventPublishingRunListener只提供了一個空的contextPrepared()方法】，        //之後初始化IoC容器，並調用SpringApplicationRunListener的contextLoaded()方法，廣播ApplicationContext的IoC加載完成，        //這裡就包括通過**@EnableAutoConfiguration**導入的各種自動配置類。      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);      //遍歷所有註冊的ApplicationRunner和CommandLineRunner，並執行其run()方法。        //我們可以實現自己的ApplicationRunner或者CommandLineRunner，來對SpringBoot的啟動過程進行擴展。      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;  }/<code> 

其實這個方法我們可以簡單的總結下步驟為 > 1. 配置屬性 > 2. 獲取監聽器，發佈應用開始啟動事件 > 3. 初始化輸入參數 > 4. 配置環境，輸出 banner > 5. 創建上下文 > 6. 預處理上下文 > 7. 刷新上下文 > 8. 再刷新上下文 > 9. 發佈應用已經啟動事件 > 10. 發佈應用啟動完成事件

其實上面這段代碼，如果只要分析 tomcat 內容的話，只需要關注兩個內容即可，上下文是如何創建的，上下文是如何刷新的，分別對應的方法就是 createApplicationContext() 和 refreshContext(context)，接下來我們來看看這兩個方法做了什麼。

<code>protected ConfigurableApplicationContext createApplicationContext() {    Class contextClass = this.applicationContextClass;    if (contextClass == null) {      try {        switch (this.webApplicationType) {        case SERVLET:          contextClass = Class.forName(DEFAULT_SERVLET_WEB_CONTEXT_CLASS);          break;        case REACTIVE:          contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);          break;        default:          contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);        }      }      catch (ClassNotFoundException ex) {        thrownew IllegalStateException(            "Unable create a default ApplicationContext, " + "please specify an ApplicationContextClass",            ex);      }    }    return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);  }/<code>

這裡就是根據我們的 webApplicationType 來判斷創建哪種類型的 Servlet,代碼中分別對應著 Web 類型(SERVLET),響應式 Web 類型（REACTIVE),非 Web 類型（default),我們建立的是 Web 類型，所以肯定實例化 DEFAULT_SERVLET_WEB_CONTEXT_CLASS 指定的類，也就是 AnnotationConfigServletWebServerApplicationContext 類

我們來用圖來說明下這個類的關係

通過這個類圖我們可以知道，這個類繼承的是 ServletWebServerApplicationContext,這就是我們真正的主角，而這個類最終是繼承了 AbstractApplicationContext，瞭解完創建上下文的情況後，我們再來看看刷新上下文，相關代碼如下：

<code>//類：SpringApplication.javaprivate void refreshContext(ConfigurableApplicationContext context) {    //直接調用刷新方法    refresh(context);    if (this.registerShutdownHook) {      try {        context.registerShutdownHook();      }      catch (AccessControlException ex) {        // Not allowed in some environments.      }    }  }//類：SpringApplication.javaprotected void refresh(ApplicationContext applicationContext) {    Assert.isInstanceOf(AbstractApplicationContext.class, applicationContext);    ((AbstractApplicationContext) applicationContext).refresh();  }/<code>

這裡還是直接傳遞調用本類的 refresh(context)方法，最後是強轉成父類 AbstractApplicationContext 調用其 refresh()方法,該代碼如下：

<code>// 類：AbstractApplicationContextpublic void refresh() throws BeansException, IllegalStateException {    synchronized (this.startupShutdownMonitor) {      // Prepare this context for refreshing.      prepareRefresh();      // Tell the subclass to refresh the internal bean factory.      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();      // Prepare the bean factory for use in this context.      prepareBeanFactory(beanFactory);      try {        // Allows post-processing of the bean factory in context subclasses.        postProcessBeanFactory(beanFactory);        // Invoke factory processors registered as beans in the context.        invokeBeanFactoryPostProcessors(beanFactory);        // Register bean processors that intercept bean creation.        registerBeanPostProcessors(beanFactory);        // Initialize message source for this context.        initMessageSource();        // Initialize event multicaster for this context.        initApplicationEventMulticaster();        // Initialize other special beans in specific context subclasses.這裡的意思就是調用各個子類的onRefresh()        onRefresh();        // Check for listener beans and register them.        registerListeners();        // Instantiate all remaining (non-lazy-init) singletons.        finishBeanFactoryInitialization(beanFactory);        // Last step: publish corresponding event.        finishRefresh();      }      catch (BeansException ex) {        if (logger.isWarnEnabled()) {          logger.warn("Exception encountered during context initialization - " +              "cancelling refresh attempt: " + ex);        }        // Destroy already created singletons to avoid dangling resources.        destroyBeans();        // Reset 'active' flag.        cancelRefresh(ex);        // Propagate exception to caller.        throw ex;      }      finally {        // Reset common introspection caches in Spring's core, since we        // might not ever need metadata for singleton beans anymore...        resetCommonCaches();      }    }  }/<code>

這裡我們看到 onRefresh()方法是調用其子類的實現，根據我們上文的分析，我們這裡的子類是 ServletWebServerApplicationContext。

<code>//類：ServletWebServerApplicationContextprotected void onRefresh() {    super.onRefresh();    try {      createWebServer();    }    catch (Throwable ex) {      thrownew ApplicationContextException("Unable to start web server", ex);    }  }private void createWebServer() {    WebServer webServer = this.webServer;    ServletContext servletContext = getServletContext();    if (webServer == null && servletContext == null) {      ServletWebServerFactory factory = getWebServerFactory();      this.webServer = factory.getWebServer(getSelfInitializer());    }    elseif (servletContext != null) {      try {        getSelfInitializer().onStartup(servletContext);      }      catch (ServletException ex) {        thrownew ApplicationContextException("Cannot initialize servlet context", ex);      }    }    initPropertySources();  }/<code>

到這裡，其實廬山真面目已經出來了，createWebServer()就是啟動 web 服務，但是還沒有真正啟動 Tomcat，既然 webServer 是通過 ServletWebServerFactory 來獲取的，我們就來看看這個工廠的真面目。

走進 Tomcat 內部

根據上圖我們發現，工廠類是一個接口，各個具體服務的實現是由各個子類來實現的

所以我們就去看看 TomcatServletWebServerFactory.getWebServer()的實現。

<code>@Override  public WebServer getWebServer(ServletContextInitializer... initializers) {    Tomcat tomcat = new Tomcat();    File baseDir = (this.baseDirectory != null) ? this.baseDirectory : createTempDir("tomcat");    tomcat.setBaseDir(baseDir.getAbsolutePath());    Connector connector = new Connector(this.protocol);    tomcat.getService().addConnector(connector);    customizeConnector(connector);    tomcat.setConnector(connector);    tomcat.getHost().setAutoDeploy(false);    configureEngine(tomcat.getEngine());    for (Connector additionalConnector : this.additionalTomcatConnectors) {      tomcat.getService().addConnector(additionalConnector);    }    prepareContext(tomcat.getHost(), initializers);    return getTomcatWebServer(tomcat);  }/<code>

根據上面的代碼，我們發現其主要做了兩件事情，第一件事就是把 Connnctor(我們稱之為連接器)對象添加到 Tomcat 中，第二件事就是 configureEngine,這連接器我們勉強能理解（不理解後面會述說），那這個 Engine 是什麼呢？

我們查看 tomcat.getEngine()的源碼：

public Engine getEngine() { Service service = getServer().findServices()[0]; if (service.getContainer() != null) { return service.getContainer(); } Engine engine = new StandardEngine(); engine.setName( "Tomcat" ); engine.setDefaultHost(hostname); engine.setRealm(createDefaultRealm()); service.setContainer(engine); return engine; }

根據上面的源碼，我們發現，原來這個 Engine 是容器，我們繼續跟蹤源碼，找到 Container 接口

上圖中，我們看到了 4 個子接口，分別是 Engine,Host,Context,Wrapper。我們從繼承關係上可以知道他們都是容器

那麼他們到底有啥區別呢？我看看他們的註釋是怎麼說的。

<code>/** If used, an Engine is always the top level Container in a Catalina * hierarchy. Therefore, the implementation's setParent() method * should throw IllegalArgumentException. * * @author Craig R. McClanahan */publicinterface Engine extends Container {    //省略代碼}/** * * The parent Container attached to a Host is generally an Engine, but may * be some other implementation, or may be omitted if it is not necessary. * * The child containers attached to a Host are generally implementations * of Context (representing an individual servlet context). * * @author Craig R. McClanahan */public interface Host extends Container {//省略代碼}/***  * The parent Container attached to a Context is generally a Host, but may * be some other implementation, or may be omitted if it is not necessary. * * The child containers attached to a Context are generally implementations * of Wrapper (representing individual servlet definitions). * * * @author Craig R. McClanahan */public interface Context extends Container, ContextBind {    //省略代碼}/** * The parent Container attached to a Wrapper will generally be an * implementation of Context, representing the servlet context (and * therefore the web application) within which this servlet executes. * * Child Containers are not allowed on Wrapper implementations, so the * addChild() method should throw an * IllegalArgumentException. * * @author Craig R. McClanahan */publicinterface Wrapper extends Container {    //省略代碼}/<code>

上面的註釋翻譯過來就是，Engine 是最高級別的容器，其子容器是 Host,Host 的子容器是 Context,Wrapper 是 Context 的子容器，所以這 4 個容器的關係就是父子關係，也就是 Engine>Host>Context>Wrapper。

我們再看看 Tomcat 類的源碼:

<code>//部分源碼，其餘部分省略。publicclass Tomcat {//設置連接器     public void setConnector(Connector connector) {        Service service = getService();        boolean found = false;        for (Connector serviceConnector : service.findConnectors()) {            if (connector == serviceConnector) {                found = true;            }        }        if (!found) {            service.addConnector(connector);        }    }    //獲取service       public Service getService() {        return getServer().findServices()[0];    }    //設置Host容器     public void setHost(Host host) {        Engine engine = getEngine();        boolean found = false;        for (Container engineHost : engine.findChildren()) {            if (engineHost == host) {                found = true;            }        }        if (!found) {            engine.addChild(host);        }    }    //獲取Engine容器     public Engine getEngine() {        Service service = getServer().findServices()[0];        if (service.getContainer() != null) {            return service.getContainer();        }        Engine engine = new StandardEngine();        engine.setName( "Tomcat" );        engine.setDefaultHost(hostname);        engine.setRealm(createDefaultRealm());        service.setContainer(engine);        return engine;    }    //獲取server       public Server getServer() {        if (server != null) {            return server;        }        System.setProperty("catalina.useNaming", "false");        server = new StandardServer();        initBaseDir();        // Set configuration source        ConfigFileLoader.setSource(new CatalinaBaseConfigurationSource(new File(basedir), null));        server.setPort( -1 );        Service service = new StandardService();        service.setName("Tomcat");        server.addService(service);        return server;    }    //添加Context容器      public Context addContext(Host host, String contextPath, String contextName,            String dir) {        silence(host, contextName);        Context ctx = createContext(host, contextPath);        ctx.setName(contextName);        ctx.setPath(contextPath);        ctx.setDocBase(dir);        ctx.addLifecycleListener(new FixContextListener());        if (host == null) {            getHost().addChild(ctx);        } else {            host.addChild(ctx);        }    //添加Wrapper容器         public static Wrapper addServlet(Context ctx,                                      String servletName,                                      Servlet servlet) {        // will do class for name and set init params        Wrapper sw = new ExistingStandardWrapper(servlet);        sw.setName(servletName);        ctx.addChild(sw);        return sw;    }}/<code>

閱讀 Tomcat 的 getServer()我們可以知道，Tomcat 的最頂層是 Server,Server 就是 Tomcat 的實例，一個 Tomcat 一個 Server

通過 getEngine()我們可以瞭解到 Server 下面是 Service，而且是多個，一個 Service 代表我們部署的一個應用，而且我們還可以知道，Engine 容器，一個 service 只有一個；根據父子關係，我們看 setHost()源碼可以知道，host 容器有多個

同理，我們發現 addContext()源碼下，Context 也是多個；addServlet()表明 Wrapper 容器也是多個，而且這段代碼也暗示了，其實 Wrapper 和 Servlet 是一層意思。另外我們根據 setConnector 源碼可以知道，連接器(Connector)是設置在 service 下的，而且是可以設置多個連接器(Connector)。

根據上面分析，我們可以小結下：Tomcat 主要包含了 2 個核心組件，連接器(Connector)和容器(Container),用圖表示如下：

一個 Tomcat 是一個 Server,一個 Server 下有多個 service，也就是我們部署的多個應用，一個應用下有多個連接器(Connector)和一個容器（Container）,容器下有多個子容器，關係用圖表示如下：

Engine 下有多個 Host 子容器，Host 下有多個 Context 子容器，Context 下有多個 Wrapper 子容器。

總結

SpringBoot 的啟動是通過 new SpringApplication()實例來啟動的，啟動過程主要做如下幾件事情：

1. 配置屬性

2. 獲取監聽器，發佈應用開始啟動事件

3. 初始化輸入參數

4. 配置環境，輸出 banner

5. 創建上下文

6. 預處理上下文

7. 刷新上下文

8. 再刷新上下文

9. 發佈應用已經啟動事件

10. 發佈應用啟動完成事件

而啟動 Tomcat 就是在第 7 步中“刷新上下文”；Tomcat 的啟動主要是初始化 2 個核心組件，連接器(Connector)和容器（Container），一個 Tomcat 實例就是一個 Server，一個 Server 包含多個 Service，也就是多個應用程序，每個 Service 包含多個連接器（Connetor）和一個容器（Container),而容器下又有多個子容器，按照父子關係分別為：Engine,Host,Context,Wrapper，其中除了 Engine 外，其餘的容器都是可以有多個。

<code>參考文獻：http://my.oschina.net/luozhou/blog/3088908/<code>

閱讀更多 BigDataKer 的文章

關鍵字: 結下 源碼 基於