tomcat之web容器

深入学习Java Web服务器系列一

一个简单的静态web容器

我们下面来实现一个简单的静态web容器。
这个服务器要实现的功能很简单，就是启动监听，当用户在浏览器输入URL发送http请求时，服务器进行解析并返回请求的静态资源。系统的时序图如下所示：
这里写图片描述

下面我们一起来实现这个简单的静态web服务器。

本文分成三个部分，第一和第二部分为知识介绍，简单介绍一下http协议和Socket协议，因为这两个协议是实现服务器的核心，我们只有熟悉这两个协议才能理解服务器的整个运作流程，第三部分我们将用代码实现这个服务器。

1. HTTP协议

HTTP是一种协议，允许web服务器和浏览器通过互联网进行来发送和接受数据。它是一种请求和响应协议。客户端请求一个文件而服务器响应请求。HTTP使用可靠的TCP连接–TCP默认使用80端口。
在HTTP中，始终都是客户端通过建立连接和发送一个HTTP请求从而开启一个事务。web服务器不需要联系客户端或者对客户端做一个回调连接。无论是客户端或者服务器都可以提前终止连接。举例来说，当你正在使用一个web浏览器的时候，可以通过点击浏览器上的停止按钮来停止一个文件的下载进程，从而有效的关闭与web服务器的HTTP连接。

HTTP请求

一个HTTP请求包括三个组成部分：

  • 方法—统一资源标识符(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

请求的头部包含了关于客户端环境和请求的主体内容的有用信息。例如它可能包括浏览器设置的语言，主体内容的长度等等。每个头部通过一个回车换行符(CRLF)来分隔的。 对于HTTP请求格式来说，头部和主体内容之间有一个回车换行符(CRLF)是相当重要的。CRLF告诉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! 
    </body> 
</html>

响应头部的第一行类似于请求头部的第一行。第一行告诉你该协议使用HTTP 1.1，请求成功(200=成功)，表示一切都运行良好。 响应头部和请求头部类似，也包括很多有用的信息。响应的主体内容是响应本身的HTML内容。头部和主体内容通过CRLF分隔开来。

2. Socket

Socket类

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

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

在这里主机是指远程机器名称或者IP地址，端口是指远程应用的端口号。

ServerSocket类

Socket类代表一个客户端套接字，即任何时候你想连接到一个远程服务器应用的时候你构造的套接字，现在，假如你想实施一个服务器应用，例如一个HTTP服务器或者FTP服务器，你需要一种不同的做法。这是因为你的服务器必须随时待命，因为它不知道一个客户端应用什么时候会尝试去连接它。为了让你的应用能随时待命，你需要使用java.net.ServerSocket类。这是服务器套接字的实现。
ServerSocket和Socket不同，服务器套接字的角色是等待来自客户端的连接请求。一旦服务器套接字获得一个连接请求，它创建一个Socket实例来与客户端进行通信。 要创建一个服务器套接字，你需要使用ServerSocket类提供的四个构造方法中的一个。你需要指定IP地址和服务器套接字将要进行监听的端口号。通常，IP地址将会是127.0.0.1，也就是说，服务器套接字将会监听本地机器。服务器套接字正在监听的IP地址被称为是绑定地址。服务器套接字的另一个重要的属性是backlog，这是服务器套接字开始拒绝传入的请求之前，传入的连接请求的最大队列长度。 其中一个ServerSocket类的构造方法如下所示:


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

3. 代码实现

下面我们来实现这个简单的服务器吧。
我们先分析一下功能，首先，我们需要有一个服务器的入口，用来监听客户端的http请求，然后还需要进行httprequest和httpresponse的请求。
所以在这里我们新建三个类，分别是

HttpServer
Request
Response

HttpServer类的功能是启动服务器监听，调用request解析http请求，调用response构造http响应
Request的功能就是解析http协议并获得请求静态资源的名称
Response的功能就是根据request来返回数据

根据上面的分析，我们可以画出下面的类图

这里写图片描述

下面来实现上面的三个类：

HttpServer类
这个类是函数的入口函数，我们在这里启动了8090端口的监听，并使用一个while轮询来进行处理httprequest，再把request传给response进行Response对象的构建。

package Series1;

import java.net.Socket;
import java.net.ServerSocket;
import java.net.InetAddress;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.IOException;
import java.io.File;

public class HttpServer {

    //WEB_ROOT为我们静态资源的目录地址，在项目的根目录下建立一个文件夹webroot
  public static final String WEB_ROOT =
    System.getProperty("user.dir") + File.separator  + "webroot";

  //入口方法
  public static void main(String[] args) {
    HttpServer server = new HttpServer();
    server.await();
  }

  //服务器监听方法，服务器监听8090端口
  public void await() {
    ServerSocket serverSocket = null;
    int port = 8090;
    try {
        //打开serversocket
      serverSocket =  new ServerSocket(port, 1, InetAddress.getByName("127.0.0.1"));
    }
    catch (IOException e) {
      e.printStackTrace();
      System.exit(1);
    }

    //轮询客户端请求
    while (true) {
      Socket socket = null;
      InputStream input = null;
      OutputStream output = null;
      try {
        socket = serverSocket.accept();
        input = socket.getInputStream();
        output = socket.getOutputStream();

        // request处理
        Request request = new Request(input);
        request.parse();

        // 创建response
        Response response = new Response(output);
        response.setRequest(request);
        response.sendStaticResource();

        //关闭连接
        socket.close();
      }
      catch (Exception e) {
        e.printStackTrace();
        continue;
      }
    }
  }
}

Request类

Response类用来获取request解析的uri的内容并发送到客户端
Request类需要实现的功能就是解析http请求，获取请求的静态资源名称

package Series1;

import java.io.InputStream;
import java.io.IOException;

public class Request {

  private InputStream input;
  private String uri;

  public Request(InputStream input) {
    this.input = input;
  }

  /**
   * 获取http请求的头数据
   */
  public void parse() {
    //读取httprequest的请求数据
    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 = parseUri(request.toString());
  }

  /**
   * 获取http请求的资源名称uri
   * @param requestString
   * @return
   */
  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;
  }

  public String getUri() {
    return uri;
  }

}

Response类

package Series1;

import java.io.OutputStream;
import java.io.IOException;
import java.io.FileInputStream;
import java.io.File;

public class Response {

  private static final int BUFFER_SIZE = 1024;
  Request request;
  OutputStream output;

  public Response(OutputStream output) {
    this.output = output;
  }

  public void setRequest(Request request) {
    this.request = request;
  }

  /**
   * 发送静态资源
   * @throws IOException
   */
  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 {
        //文件不存在
        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) {
      // 发送异常
      System.out.println(e.toString() );
    }
    finally {
      if (fis!=null)
        fis.close();
    }
  }
}

上面三个类就是这个静态web服务器的实现了，我们运行HttpServer类，在项目的根目录下新建一个webroot文件夹，并新建一个index.html文件。

<html>
<title>This is my index</title>
<body>
    Welcome!
</body>
</html>

然后在浏览器中输入http://127.0.0.1:8090/index.html
(在某些浏览器上可能不能实现，本例是在win10下的edge浏览器上演示的)

这里写图片描述

我们可以看到浏览器上输出了我们的index.html，说明我们的静态web服务器实现成功了。

总结

当我们在浏览器中输入http://127.0.0.1:8090/index.html时，浏览器会发s送一个http请求（http底层是采用socket短连接实现的）。

GET /index.html HTTP/1.1
Accept: text/html, application/xhtml+xml, image/jxr, */*
Accept-Language: zh-CN
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/51.0.2704.79 Safari/537.36 Edge/14.14393
Accept-Encoding: gzip, deflate
Host: 127.0.0.1:8090
Connection: Keep-Alive

http请求会触发HttpServer的serverSocket.accept()这个阻塞方法，继续执行后面的await()方法的代码。
然后调用 request.parse()来获取到http请求的uri=/index.html
最后通过response.sendStaticResource()获取/index.html的文件流并发送给socket客户端，也就是浏览器，这样子浏览器就可以显示index.html了。

版权声明：本文为cwfjimogudan原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接和本声明。