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

又是一个周末，这篇文章将从一个简单的例子来理解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 协议的版本。

请求的头部包含了关于客户端环境和请求的主体内容的有用信息。例如它可能包括浏览器设置的语言，主体内容的长度等等。每个头部通过一个回车换行符(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 类众多构造方法中的一个。其中一个接收主机名称和端口号:

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

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

1	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 类的构造方法如下所示:

1	public ServerSocket(int port, int backLog, InetAddress bindingAddress);

应用程序

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

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

HttpServer
Request
Response

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

应用程序不能做什么，除了发送静态资源，例如放在一个特定目录的 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 类

类结构图如下：

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请求的例子：

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

我们看第一行：

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

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

Response类

我们先看看这个类的结构图：

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请求头中的内容。并且下面还请求了一张图片。

总结

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

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

Tomcat

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

http://thinkinjava.cn/2017/11/19/2017/2017-11-19-深入理解-Tomcat（三）Tomcat-底层实现原理/

作者

莫那·鲁道

发布于

2017年11月19日

许可协议

深入理解-Tomcat（四）Tomcat-类加载器之为何违背双亲委派模型上一篇

深入理解-Tomcat-(二)-从宏观上理解-Tomcat-组件及架构下一篇