深入理解 Tomcat（三）Tomcat 底层实现原理

青旅半醒 2022-06-03 23:35 203阅读 0赞

![1240][]

又是一个周末，这篇文章将从一个简单的例子来理解tomcat的底层设计;

**本文将介绍 Java Web 服务器是如何运行的, Web 服务器也称为超文本传输协议( HyperText Transfer Protocol, HTTP)服务器, 因为它使用 Http 与其客户端(通常是 Web 浏览器)进行通信, 基于 Java 的 Web 服务器会使用两个重要的类: java.net.Socket 类和 java.net.ServerSocket 类, 并通过发送 Http 消息进行通信. 我们先花一些篇幅介绍 Http 协议（如果同学们熟悉HTTP协议可直接跳过）和这两个类, 然后写一个简单的 Web 服务器.**

#### HTTP ####

Http : Http 允许 Web 服务器和浏览器通过 Internet 发送并接受数据, 是一种基于”请求—响应”的协议, 客户端请求一个文件, 服务器端对该请求进行响应. Http 使用可靠的 tcp 连接, tcp 协议默认使用 tcp 80端口, http协议的第一个版本是 http/0.9, 后来被 http/1.0取代, 随后 http/1.0又被http/1.1取代, http/1.1 定义域 RFC(Request for Comment, 请求注解)2616中.

如果各位对 Http1.1 有更多兴趣, 请阅读 RFC 2616.

在 Http 中, 总是由客户端通过建立连接并发送 http 请求来初始化一个事务的. Web 服务器端并不负责联系客户端或建立一个到客户端的回调连接.客户端或服务器端可提前关闭连接, 例如, 当使用 Web 浏览器浏览网页时, 可以单击浏览器上的 stop 按钮来停止下载文件, 这样就有效的关闭了一个 Web 服务器的 http 连接.

#### HTTP 请求 ####

一个 HTTP 请求包含以下三部分:  
\* 请求方法—-统一资源标识符(Uniform Resource Identifier, URI)——协议/版本  
\* 请求头  
\* 实体

下面是一个 HTTP 请求的例子：

POST /examples/default.jsp HTTP/1.1 
    Accept: text/plain; text/html 
    Accept-Language: en-gb 
    Connection: Keep-Alive 
    Host: localhost 
    User-Agent: Mozilla/4.0 (compatible; MSIE 4.01; Windows 98)
    Content-Length: 33 Content-Type: application/x-www-form-urlencoded Accept-Encoding: gzip, deflate 
    
    lastName=Franks&firstName=Michael

方法—统一资源标识符(URI)—协议/版本出现在请求的第一行。  
`POST /examples/default.jsp HTTP/1.1`

这里 POST 是请求方法，`/examples/default.jsp` 是 URI，而 HTTP/1.1 是协议/版本部分。 每个 HTTP 请求可以使用 HTTP 标准里边提到的多种方法之一。HTTP 1.1 支持 7 种类型的请 求：GET, POST, HEAD, OPTIONS, PUT, DELETE 和 TRACE。GET 和 POST 在互联网应用里边最普遍使用的。

URI 完全指明了一个互联网资源。URI 通常是相对服务器的根目录解释的。因此，始终一斜 线/开头。统一资源定位器(URL)其实是一种 URI(查看 [http://www.ietf.org/rfc/rfc2396.txt][http_www.ietf.org_rfc_rfc2396.txt])  
来的。该协议版本代表了正在使用的 HTTP 协议的版本。

请求的头部包含了关于客户端环境和请求的主体内容的有用信息。例如它可能包括浏览器设 置的语言，主体内容的长度等等。每个头部通过一个回车换行符(CRLF)来分隔的。

对于 HTTP 请求格式来说，头部和主体内容之间有一个回车换行符(CRLF)是相当重要的。CRLF 告诉HTTP服务器主体内容是在什么地方开始的。在一些互联网编程书籍中，CRLF还被认为是HTTP 请求的第四部分。

在前面一个 HTTP 请求中，主体内容只不过是下面一行：

`lastName=Franks&firstName=Michael`

实体内容在一个典型的 HTTP 请求中可以很容易的变得更长。

### HTTP 响应 ###

类似于 HTTP 请求，一个 HTTP 响应也包括三个组成部分：  
\* 方法—统一资源标识符(URI)—协议/版本  
\* 响应的头部  
\* 主体内容

下面是一个 HTTP 响应的例子：

HTTP/1.1 200 OK 
    Server: Microsoft-IIS/4.0 
    Date: Mon, 5 Jan 2004 13:13:33 GMT 
    Content-Type: text/html 
    Last-Modified: Mon, 5 Jan 2004 13:13:12 GMT 
    Content-Length: 112 
    
    <html> 
        <head> 
            <title>HTTP Response Example</title> 
        </head> 
        <body> 
            Welcome to Brainy Software 
        </body> 
    </html>

响应头部的第一行类似于请求头部的第一行。第一行告诉你该协议使用 HTTP 1.1，请求成 功(200=成功)，表示一切都运行良好。

响应头部和请求头部类似，也包括很多有用的信息。响应的主体内容是响应本身的 HTML 内 容。头部和主体内容通过 CRLF 分隔开来。

### Socket 类 ###

套接字是网络连接的一个端点。套接字使得一个应用可以从网络中读取和写入数据。放在两 个不同计算机上的两个应用可以通过连接发送和接受字节流。为了从你的应用发送一条信息到另 一个应用，你需要知道另一个应用的 IP 地址和套接字端口。在 Java 里边，套接字指的是`java.net.Socket`类。

要创建一个套接字，你可以使用 Socket 类众多构造方法中的一个。其中一个接收主机名称 和端口号:

public Socket (java.lang.String host, int port)

在这里主机是指远程机器名称或者 IP 地址，端口是指远程应用的端口号。例如，要连接 yahoo.com 的 80 端口，你需要构造以下的 Socket 对象:

new Socket ("yahoo.com", 80);

一旦你成功创建了一个 Socket 类的实例，你可以使用它来发送和接受字节流。要发送字节 流，你首先必须调用Socket类的getOutputStream方法来获取一个java.io.OutputStream对象。 要 发 送 文 本 到 一 个 远 程 应 用 ， 你 经 常 要 从 返 回 的 OutputStream 对 象 中 构 造 一 个 java.io.PrintWriter 对象。要从连接的另一端接受字节流，你可以调用 Socket 类的 getInputStream 方法用来返回一个 java.io.InputStream 对象。

### ServerSocket 类 ###

Socket 类代表一个客户端套接字，即任何时候你想连接到一个远程服务器应用的时候你构 造的套接字，现在，假如你想实施一个服务器应用，例如一个 HTTP 服务器或者 FTP 服务器，你 需要一种不同的做法。这是因为你的服务器必须随时待命，因为它不知道一个客户端应用什么时 候会尝试去连接它。为了让你的应用能随时待命，你需要使用 java.net.ServerSocket 类。这是 服务器套接字的实现。

ServerSocket 和 Socket 不同，服务器套接字的角色是等待来自客户端的连接请求。一旦服 务器套接字获得一个连接请求，它创建一个 Socket 实例来与客户端进行通信。

要创建一个服务器套接字，你需要使用 ServerSocket 类提供的四个构造方法中的一个。你 需要指定 IP 地址和服务器套接字将要进行监听的端口号。通常，IP 地址将会是 127.0.0.1，也 就是说，服务器套接字将会监听本地机器。服务器套接字正在监听的 IP 地址被称为是绑定地址。 服务器套接字的另一个重要的属性是 backlog，这是服务器套接字开始拒绝传入的请求之前，传 入的连接请求的最大队列长度。

其中一个 ServerSocket 类的构造方法如下所示:

`java public ServerSocket(int port, int backLog, InetAddress bindingAddress);`

### 应用程序 ###

如果同学们下载过我们在第一篇文章提供的源码（How Tomcat Works）的话， 我们可以看一看我们的目录：

![1240 1][]

我们的 web 服务器应用程序放在 cxs01.pyrmont(编译的时候因为错误改名字了，也就懒得改回来了) 包里边，由三个类组成：  
\* HttpServer  
\* Request  
\* Response

这个应用程序的入口点(静态 main 方法)可以在 HttpServer 类里边找到。main 方法创建了 一个 HttpServer 的实例并调用了它的 await 方法。await 方法，顾名思义就是在一个指定的端 口上等待 HTTP 请求,处理它们并发送响应返回客户端。它一直等待直至接收到 shutdown 命令。  
![1240 2][]

应用程序不能做什么，除了发送静态资源，例如放在一个特定目录的 HTML 文件和图像文件。 它也在控制台上显示传入的 HTTP 请求的字节流。不过，它不给浏览器发送任何的头部例如日期 或者 cookies。

##### 下面我们来看看我们今天的重点，这三个类，也就是tomcat的雏形代码 #####

###### HttpServer 类 ######

HttpServer 类代表一个 web 服务器，也就是程序的入口，看代码：

public class HttpServer { 
      public static final String WEB_ROOT =
        System.getProperty("user.dir") + File.separator  + "webroot";
    
      // 关闭命令
      private static final String SHUTDOWN_COMMAND = "/SHUTDOWN";
    
      // 是否关闭
      private boolean shutdown = false;
    
      public static void main(String[] args) {
        HttpServer server = new HttpServer();
        server.await();
      }

main 方法中创建了一个HttpServer对象，并调用了该对象的await方法。看名字，该方法应该是等待http请求之类的东东。我们来看看方法内部：

public void await() {
        ServerSocket serverSocket = null;
        int port = 8080;
        try {
          // 创建一个socket服务器
          serverSocket =  new ServerSocket(port, 1, InetAddress.getByName("127.0.0.1"));
        }
        catch (IOException e) {
          e.printStackTrace();
          System.exit(1);
        }
    
        // 循环等待http请求
        while (!shutdown) {
          Socket socket = null;
          InputStream input = null;
          OutputStream output = null;
          try {
            // 阻塞等待http请求
            socket = serverSocket.accept();
            input = socket.getInputStream();
            output = socket.getOutputStream();
    
            // 创建一个Request对象用于解析http请求内容
            Request request = new Request(input);
            request.parse();
    
            // 创建一个Response 对象，用于发送静态文本
            Response response = new Response(output);
            response.setRequest(request);
            response.sendStaticResource();
    
            // 关闭流
            socket.close();
    
            //检查URI中是否有关闭命令
            shutdown = request.getUri().equals(SHUTDOWN_COMMAND);
          }
          catch (Exception e) {
            e.printStackTrace();
            continue;
          }
        }
      }

我们看到，该方法创建了一个Socket服务器，并循环阻塞监听http请求，当有http请求到来时， 该方法便创建一个Request对象，构造参数是socket获取的输入流对象， 用于读取客户端请求的数据并解析。 然后再创建一个Response对象，构造参数是socket的输出流对象， 并含有一个Request对象的成员变量。Response对象用于将静态页面发送给浏览器或者是其他的客户端。最后， 该方法校验请求中是否含有关闭命令的字符串，如果有，就停止服务器的运行。

这就是一个简单的服务器， 当我第一次看到的时候，心想： 真TMD简单啊。原来没那么复杂嘛。我想同学们心里想的跟我也一样吧。so， 不论多么庞大的代码，底层原理都是很简单的，只要我们学好了基础，学习起来就会轻松很多。

废话不多说，我们继续看看Request 是如何解析Http请求的吧。

##### Request 类 #####

类结构图如下：  
![image][]

Request 类代表一个 HTTP 请求。从负责与客户端通信的 Socket 中传递过来 InputStream 对象来构造这个类的一个实例。你调用 InputStream 对象其中一个 read 方法来获 取 HTTP 请求的原始数据。其中最主要的方法就是parse 和 parseUri ，他们用于逐个解析每个从客户端传递过来的字节，我们先看parse方法：

public void parse() {
        // Read a set of characters from the socket
        StringBuffer request = new StringBuffer(2048);
        int i;
        byte[] buffer = new byte[2048];
        try {
          // 读取流中内容
          i = input.read(buffer);
        }
        catch (IOException e) {
          e.printStackTrace();
          i = -1;
        }
        for (int j=0; j<i; j++) {
         // 将每个字节转换为字符
          request.append((char) buffer[j]);
        }
        // 打印字符串
        System.out.print(request.toString());
        // 根据转换出来的字符解析URI
        uri = parseUri(request.toString());
      }

我们也看到该方法是十分的简单， 创建一个StringBuffer 对象，然后从流中读取字节，然后循环将字节转成字符写入到Stringbuffer对象中。最后传入到parseUri方法中进行解析。

我们再看看parseUri方法， 这个方法中，我们前面学习的关于HTTP的知识会起作用：

private String parseUri(String requestString) {
        int index1, index2;
        // 找到第一个空格
        index1 = requestString.indexOf(' ');
        if (index1 != -1) {
          // 找到第二个空格
          index2 = requestString.indexOf(' ', index1 + 1);
          if (index2 > index1)
            // 截取第一个空格到第二个空格之间的内容
            return requestString.substring(index1 + 1, index2);
        }
        return null;
      }

该方法从请求行里边获得 URI。parseUri 方法搜索请求里边的第一个和第二个空格并从中获取 URI。  
为什么是第一个空格和第二个空格之间的内容呢？我们看看前面的Http请求的例子：

我们看第一行：  
![1240 3][]

POST 和 HTTP/1.1之间的就是我们需要的URI。so， 我们只需要将中间那段字符串截取就OK了。

我们总结一下Request类，这个类其实就是解析HTTP 消息头内容的，先将流中数据转成字节，然后将转成字符，最后将字符解析，得到自己感兴趣的内容。奏是这么简单。好了，我们再看看Response类。看看他是怎么实现的。

#### Response类 ####

我们先看看这个类的结构图：  
![1240 4][]

Response 代表了Http请求中的一个响应。我们关注其中的 sendStaticResource 方法，看名字，该方法应该是发送静态资源给客户端。我们看看代码：

public void sendStaticResource() throws IOException {
        byte[] bytes = new byte[BUFFER_SIZE];
        FileInputStream fis = null;
        try {
          File file = new File(HttpServer.WEB_ROOT, request.getUri());
          if (file.exists()) {
            // 文件存在则从输出流中输出
            fis = new FileInputStream(file);
            int ch = fis.read(bytes, 0, BUFFER_SIZE);
            while (ch!=-1) {
              output.write(bytes, 0, ch);
              ch = fis.read(bytes, 0, BUFFER_SIZE);
            }
          }
          else {
            // 没有文件返回404
            String errorMessage = "HTTP/1.1 404 File Not Found\r\n" +
              "Content-Type: text/html\r\n" +
              "Content-Length: 23\r\n" +
              "\r\n" +
              "<h1>File Not Found</h1>";
            output.write(errorMessage.getBytes());
          }
        }
        catch (Exception e) {
          // thrown if cannot instantiate a File object
          System.out.println(e.toString() );
        }
        finally {
          if (fis!=null)
            fis.close();
        }
      }

可以看到，该方法也非常的简单， sendStaticResource 方法是用来发送一个静态资源，例如一个 HTML 文件。它首先通过传递 上一级目录的路径和子路径给 File 累的构造方法来实例化 java.io.File 类。

然后它检查该文件是否存在。假如存在的话，通过传递 File 对象让 sendStaticResource 构造一个 java.io.FileInputStream 对象。然后，它调用 FileInputStream 的 read 方法并把字 节数组写入 OutputStream 对象。请注意，这种情况下，静态资源是作为原始数据发送给浏览器 的。

假如文件并不存在，sendStaticResource 方法发送一个错误信息到浏览器

运行程序，启动HttpServer mian方法，使用Edge浏览器在地址栏敲入：[http://localhost:8080/index.html][http_localhost_8080_index.html]  
返回：  
![1240 5][]

表示文件存在， 再看看我们的后台控制台：  
![1240 6][]

如期打印了http请求头中的内容。并且下面还请求了一张图片。

### 总结 ###

至此，我们已经知道了一个简单的Web服务器是如何工作的。破除了我们之前的疑惑，实际上tomcat底层就是这么实现的，可能关于阻塞IO和非阻塞NIO会有区别，但总体上还是这个思路，然后其余的组件都是针对优化性能，提高扩展性来设计新的架构。所以，我们明白了底层设计，再去学习他的设计，就不会那么迷茫。从而感到泄气。毕竟每个夜晚，我们孤独的学习，不想徒劳无功。

好了，本文结束！！！ good luck ！！！

[1240]: /images/20220604/fc42f324b1334fe2a138dddbd25a9b45.png
[http_www.ietf.org_rfc_rfc2396.txt]: http://www.ietf.org/rfc/rfc2396.txt
[1240 1]: /images/20220604/b9612916c2974f3b9a785183fc4c0435.png
[1240 2]: /images/20220604/a7682d14c7b14502a5404b6e611d0ca5.png
[image]: /images/20220604/c46f9cd65d554fb2b319db1b08523e4d.png
[1240 3]: /images/20220604/f5ece6b6579847fa956c3d26a22746f3.png
[1240 4]: /images/20220604/6e305e442873403d87cd08a884c2e805.png
[http_localhost_8080_index.html]: http://localhost:8080/index.html
[1240 5]: /images/20220604/d57b9344996a494893ee5f3a4f55265d.png
[1240 6]: /images/20220604/8452af62a36b4fef96e8b007981212c4.png