Mini Spring-Boot（二）Servlet 容器

续言

上篇文章中我们把框架的功能和结构都预定好了，从本篇开始逐步添加功能点，使它迅速丰满起来。

实现过程呢，就顺从敏捷开发思想的引导，首先使框架能 Run 起来，再通过快速迭代、小步快跑地优化。框架是没法独立运行起来的，还需要搭配上工程实现业务逻辑才行。所以，我们向项目内添加一个同级模块使用 winter 框架，这也算是 TDD 测试驱动开发的另一种表现形式了。

当然了，开始阶段只有一个入口类，项目也只依赖框架，一个普通 Main 入口类即可。

项目地址：winter-zhenbianshu-Github

转载随意，文章会持续修订，请注明来源地址：https://zhenbianshu.github.io 。

Servlet 和容器

Server

我们知道，一个 HTTP 请求被发送到服务器时，都是二进制的字节流，是操作系统的 TCP/IP 栈把这些字节流解析成带有 IP 和端口的 TCP 字节流请求，然后将字节流分配给对应的进程来处理。能够受理外部请求的进程我们暂时把它称作 socket 服务进程，每个服务进程都监听着一个服务器端口，操作系统就是根据这个端口来对应每个外部请求和服务进程的。

由上，由于服务器会监听系统的端口，受理操作系统字节流请求的应该是服务器，而职责单一的服务器是不应该跟业务耦合的，具体的业务逻辑还是应该由服务器交给我们的 Java 应用程序来处理。

规范

那么从操作系统接收到的字节流请求应该怎么给 Java 程序，Java 程序又应该怎么响应回来呢？如果每种服务器或每种 Java 程序都自己定义自己的结构，那服务器与 Java 程序的适配将成为一个大问题。这时候就需要一种规范。

于是 Java 就制定了一种标准，在 Java 语言内实现为接口，叫 Servlet，它的包全路径为 javax.servlet.Servlet。

它有五个预定义的方法：

public interface Servlet {
    // servlet 初始化方法
    public void init(ServletConfig config) throws ServletException;

    // 获取 servlet 配置
    public ServletConfig getServletConfig();

    // servlet 响应请求方法
    public void service(ServletRequest req, ServletResponse res)
            throws ServletException, IOException;

    // 获取 servlet 信息（版本、版权等）方法
    public String getServletInfo();

    // servlet 销毁方法
    public void destroy();
}

如果一个 Java 程序都实现这个接口，那么这个 Java 程序我们称为一个 servlet。而服务器保存着多个 servlet 的实例，所以 Java 服务器也被称为 servlet 容器。

流程

每个服务器会保留接口保存 servlet 和它们要处理业务逻辑（通常是 host + uri）的映射，将 uri 匹配的请求分配给 servlet，调用 servlet 的 service(ServletRequest req, ServletResponse res) 方法执行后将结果返回，这样就解决了服务器与 Java 程序的适配问题。

那么一个 HTTP 请求从发到操作系统到被 Java 程序处理后再响应的整个流程如图（实线是请求，虚线是响应）：

收到操作系统分配的字节流请求后，由服务器将这些字节流请求包装成 ServletRequest 后分派给 Java 程序处理后，Java 程序将响应结果写入 ServletRequest 传回给服务器，服务器再将响应解析为字节流响应给操作系统，再由操作系统将结果通过网络连接响应给客户端。

Tomcat

服务进程的编写就要涉及到 Java 的 sockets 编程了，对 HTTP 请求的处理和封装非常繁杂，涉及到的服务器 I/O 编程也暂不是是我们要涉及的范围，引用现成的服务器组件就是我们最好的选择了。

Tomcat 应该是 Java 开发工程师接触最多的服务器了。它是由 Java 语言编写，运行在 JVM 上的，对 Java 开发者来说很亲切。背靠 Java 和 Apache 的大腿，又有 Spring 的默认支持，市场占有率一直居高不下，当然了，高性能和对各种 I/O 模型的支持才是它成功的关键。

我们并不需要使用它的高级功能，多路复用的 I/O 模型和它默认的单实例多线程线程模型就够了。

Tomcat 从 7 开始支持嵌入式功能，我们在框架内直接实例化 org.apache.catalina.startup.Tomcat 类，再调用其 start() 方法即可启动一个 Tomcat 线程，默认监听 8080 端口，开始接受操作系统分配的字节流。

请求分发

DispatcherServlet

在 servlet 最黑暗的年代，我们需要使用 servlet 就要先定义一个类实现 Servlet 接口，这个类的 service() 方法负责处理一个或一组 uri，然后将这个 servlet 实例配置在 web.xml 中，建立起 uri 和 servlet 的映射关系，请求到达服务器时由服务器来决定调用哪个 servlet。

而在大型项目中，往往会有多组多个 uri，这也就需要我们实例化 N 个 servlet 实例，再在 web.xml 中配置多个 servlet 映射，servlet 实例和 web.xml 的管理就是个大问题，一个大而杂乱的 web.xml 配置文件让每个人看了都头大。

Spring 出现后，便用强权手段结束了服务器对 web.xml 的统治，Spring 定义了一个 DispatcherServlet，在服务器注册 servlet 时，声明它能处理 uri 匹配 "/" 的请求，也就是说所有的 uri 都由 DispatcherServlet 来处理，这样分发请求的任务全被 Spring 承包了。

至于所有请求到达 DispatcherServlet 的 service 方法后，又该交给哪个类哪个方法执行，就是 Spring 的事了，也就进入了 Spring 容器时代。

实现

Tomcat 的初始化很简单了，我们还要实现 Servlet 来受理请求，既然是模拟 Spring，我们也需要一个类似 DispatcherServlet 一样的”大总管”，我们暂时起名为 WinterServlet，方法里我们先留一些占位符，请求的分发我们在实现请求处理器后再进行分发。

public class WinterServlet implements Servlet {
    @Override
    public void init(ServletConfig config) throws ServletException {
        System.out.println("server starting...");
    }

    @Override
    public ServletConfig getServletConfig() {
        return null;
    }

    @Override
    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
        // todo dispatch requests
        System.out.println("Hello World!");
    }

    @Override
    public String getServletInfo() {
        return "Winter Framework";
    }

    @Override
    public void destroy() {
        System.out.println("server stopped.");
    }
}

连接服务器

Tomcat 容器

在 Tomcat 容器中，servlet 并不是直接依附 Tomcat 而生的，Tomcat 中将容器分为四个级别，将容器的职责进行了解耦。

下图展示了 Tomcat 中各级别容器的关系：

Engine 容器是最顶级的容器，可以理解为总控中心，在 Nginx 中就相当于 nginx.conf 文件中的配置。
Host 容器对应一个虚拟主机，管理一个主机的信息和其子容器，相当于 Nginx 中的一个 vhosts 配置。
Context 容器是最接近 servlet 的容器了，我们通过 context 可以设置一些资源属性和管理组件，Nginx 中好像并不到合适的对应，牵强一点的话就是一些日志和静态文件配置吧。
Wrapper 容器是对一个 servlet 的封装，负责 servlet 的加载、初始化、执行和销毁。

实现

我们在之前声明的 WinterServlet 和 Tomcat 之间建立联系。

   public void startTomcat() {
        // 简单地初始化一个 Tomcat 服务器
        tomcat = new Tomcat();
        tomcat.setPort(6699);
        tomcat.start();

        // 实例化一个 Context 容器的默认实现
        Context context = new StandardContext();
        context.setPath("");
        context.addLifecycleListener(new Tomcat.FixContextListener());

        // 实例化我们创建的 WinterServlet 并将它添加到 Context 容器中
        Servlet servlet = new WinterServlet();
        Tomcat.addServlet(context, "winterServlet", servlet).setAsyncSupported(true);
        context.addServletMappingDecoded("/*", "winterServlet"); // 注意其匹配的 URI 为所有

        tomcat.getHost().addChild(context);

        // 将 Tomcat 的运行包装成独立线程
        Thread awaitThread = new Thread("container-tomcat") {
            @Override
            public void run() {
                TomcatServer.this.tomcat.getServer().await();
            }
        };
        awaitThread.setContextClassLoader(getClass().getClassLoader());
        awaitThread.setDaemon(false);
        awaitThread.start();

小结

这样，一个最基本的 WEB 框架就 OK 了，虽然启动后所有的请求都只会响应 “Hello World!”。

Tomcat 容器的相关知识可以不必去纠结，毕竟太过于专有，但像 Servlet 和 Spring DispatcherServlet 这样的设计还是非常值得我们去研究和参考的。

关于本文有什么疑问可以在下面留言交流，如果您觉得本文对您有帮助，欢迎关注我的微博或 GitHub 。您也可以在我的博客REPO 右上角点击 Watch 并选择 Releases only 项来 订阅 我的博客，有新文章发布会第一时间通知您。

最近

友链

Mar 2, 2019 - Mini Spring-Boot（二）Servlet 容器

续言