28 tomcat如何处理Spring boot应用

为了方便开发和部署，Springboot在内部启动了一个嵌入式的web容器，我们知道tomcat是组件化的设计，要启动tomcat其实就是启动这些组件。在tomcat独立部署的模式下，我们通过startUp脚本来启动tomcat，tomcat中的Bootstrap和Catalina会负责初始化类加载器，并解析server.xml和启动这些组件。（init and start）

在内嵌模式下，Bootstrap和Catalina的工作就由Springboot来做了。Springboot调用了tomcat的API来启动这些组件。那springboot具体是怎么做的呢？我们如何向Springboot中的tomcat注册Servlet和Filter呢？我们又如何定制内嵌式的tomcat？

Spring Boot 中 Web 容器相关的接口

由于要支持多种Web容器，springboot对内嵌式的web容器进行了抽象，定义了WebServer接口:


public interface WebServer {
  void start() throws WebServerException;

  void stop() throws WebServerException;

  int getPort();

  default void shutDownGracefully(GracefulShutdownCallback callback) {
    callback.shutdownComplete(GracefulShutdownResult.IMMEDIATE);
  }
}

各种web容器比如tomcat需要去实现这个接口。
springboot还定义了一个工厂ServletWebServerFactory来创建Web容器，返回的对象就是Servlet类型的Web server（还有一种是ReactiveWebServerFactory，就是非Servlet类型的web应用，根据你的web应用类型做选择）。

@FunctionalInterface
public interface ServletWebServerFactory {
  WebServer getWebServer(ServletContextInitializer... initializers);
}

可以看到ServletWebServerFactory.getWebServer()有个参数ServletContextInitializer数组，他表示ServletContext的初始化器，用于ServletContext的一些配置：

@FunctionalInterface
public interface ServletContextInitializer {
  void onStartup(ServletContext servletContext) throws ServletException;
}

上面提到的getWebServer方法会调用ServletContextInitializer 的onStartup().也就是说如果你想在Servlet容器启动的时候做一些事情，比如注册你自己的Servlet，可以实现一个ServletContextInitializer，在Web容器启动时，Springboot会把所有实现了ServletContextInitializer 的接口类收集起来，统一调他们的onStartup()。

为了支持对内嵌式web容器的定制化，springboot还定义了WebServerFactoryCustomizerBeanPostProcessor接口，它是一个BeanPostProcessor，它有两个方法：postProcessBeforeInitialization和postProcessAfterInitialization。

它在 postProcessBeforeInitialization 过程中去寻找 Spring 容器中 WebServerFactoryCustomizer，类型的 Bean，并依次调用 WebServerFactoryCustomizer的customize()做一些定制化。

@FunctionalInterface
public interface WebServerFactoryCustomizer<T extends WebServerFactory> {

    /**
     * Customize the specified {@link WebServerFactory}.
     * @param factory the web server factory to customize
     */
    void customize(T factory);

}

内嵌式 Web 容器的创建和启动

铺垫了这些接口，我们再来看看Springboot是如何实例化和启动一个web容器的。我们知道Spring的核心是一个ApplicationContext，它的抽象实现类AbstractApplicationContext实现了refresh()，它用来新建或者刷新一个ApplicationContext，在refresh()中会调用onRefresh()，AbstractApplicationContext 的子类可以重写这个onRefresh()，来实现特定Context的刷新逻辑，因此AbstractApplicationContext的子类ServletWebServerApplicationContext通过重写onRefresh()来创建内嵌式的web容器，具体创建过程是这样的：org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext#onRefresh

@Override
protected void onRefresh() {
     super.onRefresh();
     try {
        // 重写 onRefresh 方法，调用 createWebServer 创建和启动 Tomcat
        createWebServer();
     }
     catch (Throwable ex) {
     }
}

createWebServer的实现：


//createWebServer 的具体实现
private void createWebServer() {
    // 这里 WebServer 是 Spring Boot 抽象出来的接口，具体实现类就是不同的 Web 容器
    WebServer webServer = this.webServer;
    ServletContext servletContext = this.getServletContext();
    
    // 如果 Web 容器还没创建
    if (webServer == null && servletContext == null) {
        // 通过 Web 容器工厂来创建
        ServletWebServerFactory factory = this.getWebServerFactory();
        // 注意传入了一个 "SelfInitializer"
        this.webServer = factory.getWebServer(new ServletContextInitializer[]{this.getSelfInitializer()});
        
    } else if (servletContext != null) {
        try {
            this.getSelfInitializer().onStartup(servletContext);
        } catch (ServletException var4) {
          ...
        }
    }
 
    this.initPropertySources();
}

getServletContext的实现：主要调用 Tomcat 的 API 去创建各种组件：

    @Override
    public WebServer getWebServer(ServletContextInitializer... initializers) {
        if (this.disableMBeanRegistry) {
            Registry.disableRegistry();
        }
                //1，实例化一个tomcat，可以理解为Server组件
        Tomcat tomcat = new Tomcat();
                //2，创建一个临时目录
        File baseDir = (this.baseDirectory != null) ? this.baseDirectory : createTempDir("tomcat");
        tomcat.setBaseDir(baseDir.getAbsolutePath());
                //3，初始化各种组件
        Connector connector = new Connector(this.protocol);
        connector.setThrowOnFailure(true);
        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);
        }
                //4，创建定制版的“Context”组件
        prepareContext(tomcat.getHost(), initializers);
        return getTomcatWebServer(tomcat);
    }

你可能会好奇prepareContext方法是做什么的呢？这里的Context是指tomcat中的Context组件，为了方便控制Context组件的行为，Spring boot定义了自己的TomcatEmbeddedContext，它扩展了Tomcat的StandardContext。

class TomcatEmbeddedContext extends StandardContext {}

注册 Servlet 的三种方式

1,Servlet注解
在Springboot启动类加上@ServletComponentScan注解后，使用@WebServlet，@WebFilter，@WebListener标记的Servlet，Filter，Listener就可以自动注册到Servlet容器中。
首先启动类

@SpringBootApplication
@ServletComponentScan
public class xxxApplication
{}

@WebServlet("/hello")
public class HelloServlet extends HttpServlet {}

在 Web 应用的入口类上加上 @ServletComponentScan，并且在 Servlet 类上加上 @WebServlet，这样 SpringBoot 会负责将 Servlet 注册到内嵌的 Tomcat 中。

2，ServletRegistrationBean
同时Springboot也提供了ServletRegistrationBean、FilterRegistrationBean和ServletListenerRegistrationBean这单个分别用来注册Servlet，Filter，Listener。加入要注册一个Servlet，可以

@Bean
public ServletRegistrationBean servletRegistrationBean() {
    return new ServletRegistrationBean(new HelloServlet(),"/hello");
}

返回的ServletRegistrationBean 会做为Spring bean注册到Spring容器中，因此你需要把这段代码放到 Spring Boot 自动扫描的目录中，或者放到 @Configuration 标识的类中。

3，动态注册
你可以写一个ServletContextInitializer 实现类，并注册为一个spring bean，springboot会负责调用这个接口的onStartup方法。

@Component
public class MyServletContextInitializer implements ServletContextInitializer {

    public void onStartUp(ServletContext servletContext){
        ServletRegistration myServlet = servletContext.addServlet("helloServlet",HelloServlet.class);
         myServlet.addMapping("/hello");
         myServlet.setInitParameter("name","Hello Servlet");
    }
}

这里请注意两点：
1，其实ServletRegistrationBean 也是通过ServletContextInitializer 实现的，因为它实现了ServletContextInitializer 接口。
2，注意到 onStartup 方法的参数是我们熟悉的 ServletContext，可以通过调用它的 addServlet 方法来动态注册新的 Servlet，这是 Servlet 3.0 以后才有的功能。

Web 容器的定制

如何在Springboot中定制web容器？
1，第一种方式是通过通用的 Web 容器工厂通过ConfigurableServletWebServerFactory来定制一些 Web 容器通用的参数：

@Component
public class MyGeneralCustomizer implements
  WebServerFactoryCustomizer<ConfigurableServletWebServerFactory> {
  
    public void customize(ConfigurableServletWebServerFactory factory) {
        factory.setPort(8081);
        factory.setContextPath("/hello");
     }
}

2,第二种方式是通过特定 Web 容器的工厂比如 TomcatServletWebServerFactory 来进一步定制。下面的例子里，我们给 Tomcat 增加一个 Valve，这个 Valve 的功能是向请求头里添加 traceid，用于分布式追踪。TraceValve 的定义如下：

class TraceValve extends ValveBase {
    @Override
    public void invoke(Request request, Response response) throws IOException, ServletException {
 
        request.getCoyoteRequest().getMimeHeaders().
        addValue("traceid").setString("1234xxxxabcd");
 
        Valve next = getNext();
        if (null == next) {
            return;
        }
 
        next.invoke(request, response);
    }
 
}

跟第一种方式类似，再添加一个定制器，代码如下：

@Component
public class MyGeneralCustomizer implements
  WebServerFactoryCustomizer<TomcatServletWebServerFactory> {
  
    public void customize(TomcatServletWebServerFactoryfactory) {
        factory.setPort(8081);
        factory.setContextPath("/hello");
        factory.addEngineValves(new TraceValve() );
     }
}

思考题

通过 ServletContextInitializer 接口可以向 Web 容器注册 Servlet，那 ServletContextInitializer 跟 Tomcat 中的 ServletContainerInitializer 有什么区别和联系呢？