Spring Boot 嵌入式Web容器

目錄

• 前言
• 一、起源
• 二、容器啓動流程解析
  • 2.一、獲取應用類型
  • 2.二、容器啓動流程
• 三、加載 Web 容器工廠
• 四、總結

前言

        最近在學習Spring Boot相關的課程，過程當中以筆記的形式記錄下來，方便之後回憶，同時也在這裏和你們探討探討，文章中有漏的或者有補充的、錯誤的都但願你們可以及時提出來，本人在此先謝謝了！

開始以前呢，但願你們帶着幾個問題去學習：
一、Spring Boot 嵌入式Web容器是什麼？
二、總體流程或結構是怎樣的？
三、核心部分是什麼？
四、怎麼實現的？
這是對自個人提問，我認爲帶着問題去學習，是一種更好的學習方式，有利於加深理解。好了，接下來進入主題。

一、起源

        在當今的互聯網場景中，與終端用戶交互的應用大多數是 Web 應用，其中 Java Web 應用尤其突出，其對應的 Java Web 容器發展至今也分爲 Servlet Web 容器和 Reactive Web 容器，前者的使用率大概佔比是百分之九十左右，其具體的實現有 Tomcat、Jetty 和 Undertow；然後者出現較晚，且技術棧體系並未徹底成熟，還有待時間驗證可行性，它的默認實現爲 Netty Web Server。其中的 Servlet 規範與三種 Servlet 容器的版本關係以下：

Servlet 規範	Tomcat	Jetty	Undertow
4.0	9.X	9.X	2.X
3.1	8.X	8.X	1.X
3.0	7.X	8.X	N/A
2.5	6.X	8.X	N/A

以上 Web 容器均被 Spring Boot 嵌入至其中做爲其核心特性，來簡化 Spring Boot應用啓動流程。Spring Boot 經過 Maven 依賴來切換應用的嵌入式容器類型，其對應的 Maven jar 分別是：

<!-- Tomcat -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-tomcat</artifactId>
</dependency>

<!-- undertow -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-undertow</artifactId>
</dependency>

<!-- jetty -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jetty</artifactId>
</dependency>

<!-- netty Web Server -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-reactor-netty</artifactId>
</dependency>

前三者是 Servlet Web 實現，最後則是 Reactive Web 的實現。值得注意的是，當咱們引用的是 Servlet Web 功能模塊時，它會自動集成 Tomcat ，裏面包含了 Tomcat 的 Maven 依賴包，也就是說 Tomcat 是默認的 Servlet Web 容器。Servlet Web 模塊的 Maven 依賴以下：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

而若是引用的是 Reactive Web 功能模塊時，則會默認集成 netty Web Server 。Reactive Web 模塊的依賴以下：

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>

不過，上面的三種 Servlet Web 容器也能做爲 Reactive Web 容器 ，並容許替換默認實現 Netty Web Server，由於 Servlet 3.1+容器一樣知足 Reactive 異步非阻塞特性。

接下來，咱們重點討論嵌入式 Web 容器的啓動流程。

注：本篇文章所用到的 Spring Boot版本是 2.1.6.BUILD-SNAPSHOT

二、容器啓動流程解析

        Spring Boot 嵌入式容器啓動時會先判斷當前的應用類型，是 Servlet Web 仍是 Reactive Web ，以後會建立相應類型的 ApplicationContext 上下文，在該上下文中先獲取容器的工廠類，而後利用該工廠類建立具體的容器。接下來，咱們進行詳細討論。

從 Spring Boot 啓動類開始：

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

2.一、獲取應用類型

先來看看，獲取應用類型的過程，進入 run 的重載方法：

public class SpringApplication {

    // 一、該方法中，先構造 SpringApplication 對象，再調用該對象的 run 方法。咱們進入第二步查看構造過程
    public static ConfigurableApplicationContext run(Class<?>[] primarySources,
            String[] args) {
        return new SpringApplication(primarySources).run(args);
    }
    
    // 二、webApplicationType 存儲的就是應用的類型，經過 deduceFromClasspath 方法返回。
    // 咱們進入第三步查看該方法實現
    public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
        ...
        this.webApplicationType = WebApplicationType.deduceFromClasspath();
        ...
    }
}

public enum WebApplicationType {

    private static final String[] SERVLET_INDICATOR_CLASSES = { "javax.servlet.Servlet",
            "org.springframework.web.context.ConfigurableWebApplicationContext" };

    private static final String WEBMVC_INDICATOR_CLASS = "org.springframework." + "web.servlet.DispatcherServlet";

    private static final String WEBFLUX_INDICATOR_CLASS = "org." + "springframework.web.reactive.DispatcherHandler";

    private static final String JERSEY_INDICATOR_CLASS = "org.glassfish.jersey.servlet.ServletContainer";

    // 三、這裏實際上是根據引入的 Web 模塊 jar 包，來判斷是否包含各 Web 模塊的類，來返回相應的應用類型
    static WebApplicationType deduceFromClasspath() {
    
        // 當 DispatcherHandler 類存在，DispatcherServlet 和 ServletContainer 不存在時，
        // 返回 Reactive ，表示當前 Spring Boot 應用類型是 Reactive Web 。
        // 前者是 Reactice Web jar 中的類，後二者是 Servlet Web 中的。
        if (ClassUtils.isPresent(WEBFLUX_INDICATOR_CLASS, null) && !ClassUtils.isPresent(WEBMVC_INDICATOR_CLASS, null)
                && !ClassUtils.isPresent(JERSEY_INDICATOR_CLASS, null)) {
            return WebApplicationType.REACTIVE;
        }
        
        // 這裏判斷是非 Web 應用類型
        for (String className : SERVLET_INDICATOR_CLASSES) {
            if (!ClassUtils.isPresent(className, null)) {
                return WebApplicationType.NONE;
            }
        }
        
        // 以上都不知足時，最後返回 Servlet 。
        return WebApplicationType.SERVLET;
    }
}

以上，在 SpringApplication 的構造階段肯定了當前應用的類型，該類型名稱存儲在 webApplicationType 字段中。

2.二、容器啓動流程

接着進入容器啓動流程，進入重載的 run 方法中：

public class SpringApplication {

    public static final String DEFAULT_CONTEXT_CLASS = "org.springframework.context."
            + "annotation.AnnotationConfigApplicationContext";

    public static final String DEFAULT_WEB_CONTEXT_CLASS = "org.springframework.boot."
            + "web.servlet.context.AnnotationConfigServletWebServerApplicationContext";
            
    public static final String DEFAULT_REACTIVE_WEB_CONTEXT_CLASS = "org.springframework."
            + "boot.web.reactive.context.AnnotationConfigReactiveWebServerApplicationContext";
            
    ...
    
    private WebApplicationType webApplicationType;
    
    ...
    
    public ConfigurableApplicationContext run(String... args) {
        ...
        
        ConfigurableApplicationContext context = null;
        
        try {
            ...
            // 一、經過 createApplicationContext 方法建立對應的 ApplicationContext 應用上下文，進入 1.1 查看具體實現
            context = createApplicationContext();
            
            ...
            
            // 二、該方法實質是啓動 Spring 應用上下文的，但 Spring Boot 嵌入式容器也在該過程當中被啓動，入參是上下文對象，咱們進入 2.1 進行跟蹤
            refreshContext(context);
            
            ...
        }
        ...
    }
    
    // 1.一、
    protected ConfigurableApplicationContext createApplicationContext() {
        Class<?> contextClass = this.applicationContextClass;
        if (contextClass == null) {
            try {
            
                // 這裏就是經過 webApplicationType 屬性，判斷應用類型，來建立不一樣的 ApplicationContext 應用上下文
                switch (this.webApplicationType) {
                case SERVLET:
                    
                    // 返回的是 Servlet Web ，具體對象爲 AnnotationConfigServletWebServerApplicationContext，
                    // 該類有一個關鍵父類 ServletWebServerApplicationContext
                    contextClass = Class.forName(DEFAULT_WEB_CONTEXT_CLASS);
                    break;
                case REACTIVE:
                
                    // 返回的是 Reactive Web，具體對象爲 AnnotationConfigReactiveWebServerApplicationContext
                    contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);
                    break;
                default:
                
                    // 應用類型是非 Web 時，返回 AnnotationConfigApplicationContext
                    contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);
                }
            }
            ...
        }
        return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
    }
    
    // 2.1
    private void refreshContext(ConfigurableApplicationContext context) {
        
        // 裏面調用的是 refresh 方法，進入 2.2 繼續跟蹤
        refresh(context);
        
        ...
    }
    
    // 2.2
    protected void refresh(ApplicationContext applicationContext) {
        Assert.isInstanceOf(AbstractApplicationContext.class, applicationContext);
        
        // 最終調用了 全部應用上下文的統一抽象類 AbstractApplicationContext 中的 refresh 方法，進入 3 查看實現
        ((AbstractApplicationContext) applicationContext).refresh();
    }
    
    ...
}

AbstractApplicationContext 是 Spring 應用上下文的核心啓動類，Spring 的 ioc 從這裏就開始進入建立流程。在後續在 Spring 系列的文章中會進行詳細討論，咱們這裏只關注容器建立的部分。

public abstract class AbstractApplicationContext extends DefaultResourceLoader
        implements ConfigurableApplicationContext {
    
    ...
    
    // 3
    @Override
    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            
            try {
                ...
                
                // Web 容器在這個方法中啓動，但在當前抽象類中這個方法是個空實現，具體由 ApplicationContext 上下文的子類對象進行重寫，
                // 咱們進入 4 查看其中一個子類的實現
                onRefresh();

                ...
            }
        }
        ...
    }
    ...
}

這裏以 Servlet web 爲例，具體上下文對象是 AnnotationConfigServletWebServerApplicationContext，該類實現了 ServletWebServerApplicationContext 類，onRefresh 方法由該類進行重寫。

public class ServletWebServerApplicationContext extends GenericWebApplicationContext
        implements ConfigurableWebServerApplicationContext {
    ...
    
    // 4
    @Override
    protected void onRefresh() {
        
        ...
        
        try {
        
            // 裏面調用了 createWebServer 方法，進入 5 查看實現
            createWebServer();
        }
        catch (Throwable ex) {
            throw new ApplicationContextException("Unable to start web server", ex);
        }
    }
    
    ...
    
    // 5
    private void createWebServer() {
        
        // WebServer 就是容器對象，是一個接口，其對應的實現類分別是：
        // JettyWebServer、TomcatWebServer、UndertowWebServer、NettyWebServer。這些容器對象由對應的容器工廠類進行建立
        WebServer webServer = this.webServer;
        ServletContext servletContext = getServletContext();
        
        // 當 webServer 等於 null ，也就是容器還沒建立時，進入該 if 中
        if (webServer == null && servletContext == null) {
            
            // 這裏是獲取 建立 Servlet Web 容器的工廠類，也是一個接口，有三個實現，分別是：
            // JettyServletWebServerFactory、TomcatServletWebServerFactory、UndertowServletWebServerFactory
            ServletWebServerFactory factory = getWebServerFactory();
            
            // 經過容器工廠類的 getWebServer 方法，建立容器對象。這裏以建立 Tomcat 爲例，來繼續跟蹤容器的建立流程，
            // 跳到 6 查看 TomcatServletWebServerFactory 的 getWebServer 方法
            this.webServer = factory.getWebServer(getSelfInitializer());
        }
        
        ...
    }
}

TomcatServletWebServerFactory 是建立 Tomcat 的 Web 容器工廠類，但這個工廠類是如何被建立的呢？這裏將會在文章的第三部分進行詳細討論。

public class TomcatServletWebServerFactory extends AbstractServletWebServerFactory
        implements ConfigurableTomcatWebServerFactory, ResourceLoaderAware {
    
    ...
    // 六、
    @Override
    public WebServer getWebServer(ServletContextInitializer... initializers) {
        
        // 方法中先進行建立 Tomcat 的流程，如 Container 、Engine、Host、Servlet 幾個容器的組裝。
        // 後續有機會再對 Tomcat 進行詳細討論，這裏就不深刻了
        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);
        
        // 經過 getTomcatWebServer 方法返回 TomcatWebServer 容器對象。進入 7 查看接下來的流程
        return getTomcatWebServer(tomcat);
    }
    
    ...
    
    // 七、這裏經過 TomcatWebServer 的構造方法建立該對象。進入 8 繼續跟蹤
    protected TomcatWebServer getTomcatWebServer(Tomcat tomcat) {
        return new TomcatWebServer(tomcat, getPort() >= 0);
    }
    
    ...
}

TomcatWebServer 是具體的容器對象，在其對應的工廠類中進行建立，其實現了 WebServer 接口，並在該對象中進行 Tomcat 的啓動流程。

public class TomcatWebServer implements WebServer {

    ...

    // 八、
    public TomcatWebServer(Tomcat tomcat, boolean autoStart) {
        Assert.notNull(tomcat, "Tomcat Server must not be null");
        this.tomcat = tomcat;
        this.autoStart = autoStart;
        
        // 進入 initialize 方法中，查看實現
        initialize();
    }

    private void initialize() throws WebServerException {
        logger.info("Tomcat initialized with port(s): " + getPortsDescription(false));
        synchronized (this.monitor) {
            try {
            
                ...

                // 調用 Tomcat 的 start 方法，正式啓動
                this.tomcat.start();

                ...
                
                // 啓動守護線程來監聽http請求 
                startDaemonAwaitThread();
            }
            ...
        }
    }
    
    ...
}

到這裏，Web 容器的啓動流程就結束了，以上是以 Servlet Web 及其具體的 Tomcat 容器爲例子進行的討論，這也是大部分開發者經常使用的體系。接着來對整個過程作一個總結。

• 首先經過引入的 Web 模塊 Maven 依賴 ，來判斷當前應用的類型，如 Servlet Web 或 Reactive Web。並根據應用類型來建立相應的 ApplicationContext 上下文對象。
• 而後調用了 ApplicationContext 的父抽象類 AbstractApplicationContext 中的 refresh 方法，又在該方法中調用了子類的 onRefresh 方法。
• 最後是在 onRefresh 中經過容器的工廠類建立具體容器對象，並在該容器對象中進行啓動。

三、加載 Web 容器工廠

        上面說過， Web 容器對象是由其對應的工廠類進行建立的，那容器工廠類又是怎麼建立呢？咱們這裏就來看一看。在《Spring Boot 自動裝配（二）》的 1.2 小節說過， Spring Boot 啓動時，會讀取全部 jar 包中 META-INF 文件夾下的 spring.factories 文件，並加載文件中定義好的類，如：

...
# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.web.servlet.ServletWebServerFactoryAutoConfiguration,\

...

其中有一個 ServletWebServerFactoryAutoConfiguration 類：

@Configuration
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
@ConditionalOnClass(ServletRequest.class)
@ConditionalOnWebApplication(type = Type.SERVLET)
@EnableConfigurationProperties(ServerProperties.class)
@Import({ ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class,
        ServletWebServerFactoryConfiguration.EmbeddedTomcat.class,
        ServletWebServerFactoryConfiguration.EmbeddedJetty.class,
        ServletWebServerFactoryConfiguration.EmbeddedUndertow.class })
public class ServletWebServerFactoryAutoConfiguration {
    ...
}

該類經過 @Import 導入了 ServletWebServerFactoryConfiguration 中的三個內部類，這三個內部類就是用來建立容器工廠，咱們進入其中查看具體實現：

@Configuration
class ServletWebServerFactoryConfiguration {

    // 經過 @ConditionalOnClass 判斷 Servlet 、Tomcat、UpgradeProtocol 這三個 Class 是否存在，
    // 當引用的是 Tomcat Maven 依賴時，則 Class 才存在，並建立 Tomcat 的容器工廠類 TomcatServletWebServerFactory
    @Configuration
    @ConditionalOnClass({ Servlet.class, Tomcat.class, UpgradeProtocol.class })
    @ConditionalOnMissingBean(value = ServletWebServerFactory.class, search = SearchStrategy.CURRENT)
    public static class EmbeddedTomcat {

        @Bean
        public TomcatServletWebServerFactory tomcatServletWebServerFactory() {
            return new TomcatServletWebServerFactory();
        }
    }

    // 當引用的是 Jetty Maven 依賴時，@ConditionalOnClass 條件才知足，
    // 建立的容器工廠類是 JettyServletWebServerFactory 
    @Configuration
    @ConditionalOnClass({ Servlet.class, Server.class, Loader.class, WebAppContext.class })
    @ConditionalOnMissingBean(value = ServletWebServerFactory.class, search = SearchStrategy.CURRENT)
    public static class EmbeddedJetty {

        @Bean
        public JettyServletWebServerFactory JettyServletWebServerFactory() {
            return new JettyServletWebServerFactory();
        }
    }

    // 當引用的是 Undertow Maven 依賴時，@ConditionalOnClass 條件才知足，
    // 建立的容器工廠類是 UndertowServletWebServerFactory 
    @Configuration
    @ConditionalOnClass({ Servlet.class, Undertow.class, SslClientAuthMode.class })
    @ConditionalOnMissingBean(value = ServletWebServerFactory.class, search = SearchStrategy.CURRENT)
    public static class EmbeddedUndertow {

        @Bean
        public UndertowServletWebServerFactory undertowServletWebServerFactory() {
            return new UndertowServletWebServerFactory();
        }
    }

能夠看到，主要是經過引入相應 Web 容器的 Maven 依賴，來判斷容器對應的 Class 是否存在，存在則建立相應的容器工廠類。

四、總結

        最後，來對 Spring Boot 嵌入式 Web 容器作一個總體的總結。Spring Boot 支持的兩大 Web 容器體系，一個是 Servlet Web ，另外一個是 Reactive Web ，它們都有其具體的容器實現，相信大多數開發者使用的都是前者，且最經常使用的容器實現也是 Tomcat，因此這篇文章主要討論的也是 Spring Boot 啓動 Tomcat 嵌入式容器的流程。

以上就是本章的內容，若是文章中有錯誤或者須要補充的請及時提出，本人感激涕零。