Tomcat 源码详解第一课 -- 如何设计一个简单的 Web 容器

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 对象。

2.2. SeverSocket

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);

三. 一个简单 Web 容器的设计和实现：对静态资源

准备，这个例子来源于《How Tomcat Works》

注意：当你跑如下程序时，可能会由于浏览器新版本不再支持的 HTTP 0.9 协议，而造成浏览器页面没有返回信息。

3.1. 组件设计

根据上述的基础，我们可以看到，我们只需要提供三个最基本的类，分别是：

Request - 表示请求，这里表示浏览器发起的 HTTP 请求
HttpServer - 表示处理请求的服务器，同时这里使用我们上面铺垫的 ServerSocket
Reponse - 表示处理请求后的响应，这里表示服务器对 HTTP 请求的响应结果

3.2. 组件实现

从上图中我们可以看到，组织这几个类的入口在 Server 的启动方法中，即 main 方法中, 所以我们透过 main 方法从 Server 类进行分析：

Server是如何启动的？

public class HttpServer {

  // 存放静态资源的位置
  public static final String WEB_ROOT =
    System.getProperty("user.dir") + File.separator  + "webroot";

  // 关闭Server的请求
  private static final String SHUTDOWN_COMMAND = "/SHUTDOWN";

  // 是否关闭Server
  private boolean shutdown = false;

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

  public void await() {
    // 启动ServerSocket
    ServerSocket serverSocket = null;
    int port = 8080;
    try {
      serverSocket =  new ServerSocket(port, 1, InetAddress.getByName("127.0.0.1"));
    }
    catch (IOException e) {
      e.printStackTrace();
      System.exit(1);
    }

    // 循环等待一个Request请求
    while (!shutdown) {
      Socket socket = null;
      InputStream input = null;
      OutputStream output = null;
      try {
        // 创建socket
        socket = serverSocket.accept();
        input = socket.getInputStream();
        output = socket.getOutputStream();

        // 封装input至request, 并处理请求
        Request request = new Request(input);
        request.parse();

        // 封装output至response
        Response response = new Response(output);
        response.setRequest(request);
        response.sendStaticResource();

        // 关闭socket
        socket.close();

        // 如果接受的是关闭请求，则设置关闭监听request的标志
        shutdown = request.getUri().equals(SHUTDOWN_COMMAND);
      }
      catch (Exception e) {
        e.printStackTrace();
        continue;
      }
    }
  }
}

Request请求是如何封装和处理的？

public class Request {

  private InputStream input;
  private String uri;

  // 初始化Request
  public Request(InputStream input) {
    this.input = input;
  }

  // 处理request的方法
  public void parse() {
    // 从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());

    // 获得两个空格之间的内容, 这里将是HttpServer.WEB_ROOT中静态文件的文件名称
    uri = parseUri(request.toString());
  }

  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 中响应了什么？

public class Response {

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

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

  // response中封装了request，以便获取request中的请求参数
  public void setRequest(Request request) {
    this.request = request;
  }

  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();
    }
  }
}

启动输出

当我们 run上面 HttpServer 中的 main 方法之后，我们就可以打开浏览器 http://localhost:8080，后面添加参数看返回 webroot 目录中静态文件的内容了（比如这里我加了 hello.txt 文件到 webroot下，并访问 http://localhost:8080/hello.txt）。

四. 一个简单 Web 容器的设计和实现：对 Servelet

上面这个例子是不是很简单？是否打破了对一个简单 http 服务器的认知，减少了对它的恐惧。

但是上述的例子中只处理了静态资源，我们如果要处理 Servlet 呢？

4.1. 组件设计

不难发现，我们只需要在 HttpServer 只需要请求的处理委托给 ServletProcessor，让它接受请求，并处理 Response 即可。

4.2. 组件实现

在 HttpServer 中

public void await() {
    //....

        // create Response object
        Response response = new Response(output);
        response.setRequest(request);

        // 不再有response自己处理
        //response.sendStaticResource();

        // 而是如果以/servlet/开头，则委托ServletProcessor处理
        if (request.getUri().startsWith("/servlet/")) {
          ServletProcessor1 processor = new ServletProcessor1();
          processor.process(request, response);
        } else {
          // 原有的静态资源处理
          StaticResourceProcessor processor = new StaticResourceProcessor();
          processor.process(request, response);
        }

    // ....
  }

ServletProcessor 如何处理的？

public class ServletProcessor1 {

  public void process(Request request, Response response) {

    // 获取servlet名字
    String uri = request.getUri();
    String servletName = uri.substring(uri.lastIndexOf("/") + 1);
    
    // 初始化URLClassLoader
    URLClassLoader loader = null;
    try {
      // create a URLClassLoader
      URL[] urls = new URL[1];
      URLStreamHandler streamHandler = null;
      File classPath = new File(Constants.WEB_ROOT);
      // the forming of repository is taken from the createClassLoader method in
      // org.apache.catalina.startup.ClassLoaderFactory
      String repository = (new URL("file", null, classPath.getCanonicalPath() + File.separator)).toString() ;
      // the code for forming the URL is taken from the addRepository method in
      // org.apache.catalina.loader.StandardClassLoader class.
      urls[0] = new URL(null, repository, streamHandler);
      loader = new URLClassLoader(urls);
    } catch (IOException e) {
      System.out.println(e.toString() );
    }

    // 用classLoader加载上面的servlet
    Class myClass = null;
    try {
      myClass = loader.loadClass(servletName);
    }
    catch (ClassNotFoundException e) {
      System.out.println(e.toString());
    }

    // 将加载到的class转成Servlet，并调用service方法处理
    Servlet servlet = null;
    try {
      servlet = (Servlet) myClass.newInstance();
      servlet.service((ServletRequest) request, (ServletResponse) response);
    } catch (Exception e) {
      System.out.println(e.toString());
    } catch (Throwable e) {
      System.out.println(e.toString());
    }

  }
}

Repsonse

public class PrimitiveServlet implements Servlet {

  public void init(ServletConfig config) throws ServletException {
    System.out.println("init");
  }

  public void service(ServletRequest request, ServletResponse response)
    throws ServletException, IOException {
    System.out.println("from service");
    PrintWriter out = response.getWriter();
    out.println("Hello. Roses are red.");
    out.print("Violets are blue.");
  }

  public void destroy() {
    System.out.println("destroy");
  }

  public String getServletInfo() {
    return null;
  }
  public ServletConfig getServletConfig() {
    return null;
  }

}

访问 URL

4.3. 利用外观模式改造

上述代码存在一个问题，

// 将加载到的class转成Servlet，并调用service方法处理
Servlet servlet = null;
try {
    servlet = (Servlet) myClass.newInstance();
    servlet.service((ServletRequest) request, (ServletResponse) response);
} catch (Exception e) {
    System.out.println(e.toString());
} catch (Throwable e) {
    System.out.println(e.toString());
}

这里直接处理将 request 和 response 传给 servlet 处理是不安全的，因为 request 可以向下转型为Request 类，从而 ServeletRequest 便具备了访问 Request 中方法的能力。

public class Request implements ServletRequest {
  // 一些public方法
}

public class Response implements ServletResponse {

}

解决的方法便是通过外观模式进行改造：

RequestFacade 为例

public class RequestFacade implements ServletRequest {

  private ServletRequest request = null;

  public RequestFacade(Request request) {
    this.request = request;
  }

  /* implementation of the ServletRequest*/
  public Object getAttribute(String attribute) {
    return request.getAttribute(attribute);
  }

  public Enumeration getAttributeNames() {
    return request.getAttributeNames();
  }

  public String getRealPath(String path) {
    return request.getRealPath(path);
  }

...

Process 中由传入外观类

Servlet servlet = null;
RequestFacade requestFacade = new RequestFacade(request); // 转换成外观类
ResponseFacade responseFacade = new ResponseFacade(response);// 转换成外观类
try {
  servlet = (Servlet) myClass.newInstance();
  servlet.service((ServletRequest) requestFacade, (ServletResponse) responseFacade);
}
catch (Exception e) {
  System.out.println(e.toString());
}
catch (Throwable e) {
  System.out.println(e.toString());
}

当我们看到这么一个简单的 Web 容器实现之后，我们便不再觉得 Tomcat 高高在上；这将为我们继续分析 Tomcat 中核心源码提供基础。

原文地址：https://blog.csdn.net/mrluo735/article/details/142385338

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：「Mac畅玩鸿蒙与硬件15」鸿蒙UI组件篇5 - Slider 和 Progress 组件
下一篇：Mac 配置SourceTree集成云效

数据结构 —— 红黑树
新增结点标识为c(cur)，c的⽗亲标识为p(parent)，p的⽗亲标识为 g(grandfather)，p的兄弟标识为u（uncle)新增结点标识为c(cur)，c的⽗亲标识为p(parent)，
阅读更多2024-11-06
【RDD算子的分类】RDD的转换算子和触发算子（行为算子）、以及各个算子的作用，对比sql中的关键字
RDD算子的分类：RDD的转换算子和触发算子（行为算子）、以及各个算子的作用，对比sql中的关键字
阅读更多2024-11-06
TCP/IP协议简介
计算机通信协议是对那些计算机必须遵守以便彼此通信的规则的描述。这些规则定义了数据传输的方式、格式、时序和错误检测等各个方面。其中最著名且广泛应用的协议之一便是TCP/IP（传输控制协议/网际协议）。T
阅读更多2024-11-06
【SQL实验】高级查询（包含导入ACCESS数据的详细操作）
下载，打开SSMS（集成管理器），新建一个“书籍管理”的数据库，并将素材的中的ACCESS数据导入到该数据库右键点击“数据库”节点，选择“新建数据库”。在弹出的窗口中，设置数据库名称为“书籍管理”，点
阅读更多2024-11-06
【Seed-Labs】SQL Injection Attack Lab
SQL Injection Attacks Lab
阅读更多2024-11-06
详细分析SQL state [99999]； error code [17059]；无法转换为内部表示解决方法（实战讲解）
Error attempting to get column 'ID' from result set. Cause: java.sql.SQLException: 无法转换为内部表示 ; uncat
阅读更多2024-11-06
麒麟V10SP1部署postgresql+postgis+pgrouting
编译过程中如报PNG错误，需修改代码：vi /gdal-3.3.3/frmts/png/libpng/pngpriv.h。在#ifndef PNG_ARM_NEON_OPT行上增加#define PN
阅读更多2024-11-06
Java继承练习
创建一个员工类（属性：名字、年龄、工作天数、日结工资，方法：打印工资），创建经理类和普通员工继承员工类且重写打印工资的方法。，经理类新增工资算法，原工资+奖金。
阅读更多2024-11-06
什么是ajax，为什么使用ajax？ajax都有哪些优点和缺点？
AJAX 是一种强大且灵活的技术，适用于提高网页的交互性和用户体验。在使用 AJAX 时，开发者需权衡其优缺点，考虑项目的具体需求和目标。通过合理地设计和实现，可以最大程度地发挥 AJAX 的优势。
阅读更多2024-11-06
性能测试策略模型测试类型选取建议
根据具体测试目的，可通过增删来选取适当的性能测试类型。估计未来增长所需资源量的过程。基于当前使用情况及预测的增长趋势来进行预测，确保。此类测试有助于发现随着时间推移可能出现的问题，如。这对于确保服务即
阅读更多2024-11-06

Tomcat 源码详解第一课 -- 如何设计一个简单的 Web 容器

一. 前言

二. 基础认知：如何实现服务器和客户端（浏览器）的交互

2.1. Socket