深入剖析Tomcat之请求处理全流程

原创于 2025-05-21 22:12:03 发布 · 1k 阅读

9 ·

CC 4.0 BY-SA版权

文章标签：

#tomcat #java

深入剖析Tomcat之请求处理全流程

在Java Web开发的世界里，Tomcat作为一款广泛使用的开源服务器，其内部请求处理机制十分复杂且精妙。今天，我希望能和大家一起深入探讨Tomcat的请求处理过程，在学习中共同进步。

一、Tomcat请求处理前的准备工作

在深入了解请求处理流程之前，我们得先熟悉几个关键的对象，它们是请求处理过程中的重要参与者。

（一）Request对象

Request对象在Tomcat中用于封装HTTP请求的相关信息。它是org.apache.catalina.Request接口的实例，由一系列类实现，如RequestBase、HttpRequest，最终的实现类是HttpRequestImpl。此外，还有外观类RequestFacade和HttpRequestFacade，它们提供了统一的接口来访问请求的各种属性和方法。

想象一下，Request对象就像是一个装满了各种请求信息的包裹，里面有请求的方法（比如GET、POST）、请求的URI、请求头信息等等。我们可以通过下面的代码示例来感受一下如何获取这些信息：

import org.apache.catalina.Request;
import org.apache.catalina.RequestFacade;
import org.apache.catalina.core.RequestBase;
import org.apache.catalina.core.HttpRequest;
import org.apache.catalina.core.HttpRequestImpl;

public class RequestInfoExample {
    public static void main(String[] args) {
        // 模拟创建一个Request对象
        Request request = new HttpRequestImpl();
        RequestFacade facade = new RequestFacade(request);

        // 模拟设置请求方法和请求URI
        ((HttpRequest) request).setMethod("GET");
        ((HttpRequest) request).setRequestURI("/test");

        // 获取并打印请求方法和请求URI
        String method = facade.getMethod();
        String uri = facade.getRequestURI();
        System.out.println("请求方法: " + method);
        System.out.println("请求URI: " + uri);
    }
}

（二）Response对象

Response对象则负责封装服务器对请求的响应信息。它的相关实现类通过UML类图可以清晰地看到继承和实现关系。Response对象就像是一个装满了服务器响应内容的包裹，包括响应头信息、响应体内容等。在后续的请求处理过程中，我们会看到它是如何被填充和使用的。

二、HttpProcessor类的process()方法：请求处理核心

当Socket对象被赋值给HttpProcessor类后，其run()方法会调用process()方法，这个方法是请求处理的核心，它主要执行以下几个重要操作：解析连接、解析请求、解析请求头。

（一）初始化相关变量和对象

process()方法首先会初始化一些关键的变量和对象。比如，用布尔变量ok来表示处理过程中是否有错误发生，finishResponse来表示是否应该调用Response接口的finishResponse()方法；还有keepAlive、stopped和http11等布尔变量，分别用于判断连接是否是持久连接、HttpProcessor实例是否被终止以及HTTP请求是否来自支持HTTP 1.1的客户端。

同时，会创建SocketInputStream实例来包装套接字的输入流，OutputStream实例用于输出响应数据。下面是一个简单的代码模拟这部分初始化过程：

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

public class HttpProcessorProcessMock {
    private boolean ok = true;
    private boolean finishResponse = true;
    private boolean keepAlive = true;
    private boolean stopped = false;
    private boolean http11 = true;
    private Socket socket;

    public void process() {
        SocketInputStream input = null;
        OutputStream output = null;
        try {
            input = new SocketInputStream(socket.getInputStream());
            output = socket.getOutputStream();
        } catch (IOException e) {
            ok = false;
        }
        // 后续处理逻辑
    }
}

class SocketInputStream {
    public SocketInputStream(InputStream inputStream) {
        // 模拟初始化操作
    }
}

（二）进入请求处理循环

初始化完成后，process()方法会进入一个while循环，这个循环会不断读取输入流，直到满足特定条件才会结束。在循环内部，首先会将finishResponse设置为true，然后对request和response对象进行一些初始化操作，比如设置它们的输入输出流、关联彼此等。

接着，会调用parseConnection()、parseRequest()和parseHeaders()方法来解析HTTP请求。这几个方法就像是三个精细的工匠，分别负责从请求中提取连接信息、请求信息和请求头信息。例如，parseConnection()方法会获取请求所使用的协议，如果是HTTP 1.0，就会将keepAlive设置为false，因为HTTP 1.0不支持持久连接。

下面是模拟这部分解析请求的代码：

public class HttpProcessorParseMock {
    private boolean ok = true;
    private boolean finishResponse = true;
    private boolean keepAlive = true;
    private boolean http11 = true;
    private Request request;
    private Response response;
    private SocketInputStream input;
    private OutputStream output;

    public void process() {
        while (!stopped && ok && keepAlive) {
            finishResponse = true;
            try {
                request.setResponse(response);
                request.setStream(input);
                response.setStream(output);
                response.setRequest(request);
            } catch (Exception e) {
                ok = false;
            }
            if (ok) {
                parseConnection();
                parseRequest();
                if (!request.getRequest().getProtocol().startsWith("HTTP/0")) {
                    parseHeaders();
                }
            }
        }
    }

    private void parseConnection() {
        // 模拟解析连接，设置协议等信息
        String protocol = "HTTP/1.1";
        if ("HTTP/1.0".equals(protocol)) {
            keepAlive = false;
        }
    }

    private void parseRequest() {
        // 模拟解析请求，设置请求方法、URI等信息
    }

    private void parseHeaders() {
        // 模拟解析请求头，设置相关信息
    }
}

class Request {
    private Response response;
    private SocketInputStream stream;
    private String protocol;

    public void setResponse(Response response) {
        this.response = response;
    }

    public void setStream(SocketInputStream stream) {
        this.stream = stream;
    }

    public String getProtocol() {
        return protocol;
    }

    public Request getRequest() {
        return this;
    }
}

class Response {
    private Request request;
    private OutputStream stream;

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

    public void setStream(OutputStream stream) {
        this.stream = stream;
    }
}

（三）处理异常和后续操作

在解析HTTP请求的过程中，如果发生任何异常，都会将ok或finishResponse设置为false。完成解析后，process()方法会将request和response对象作为参数传入servlet容器的invoke()方法，让servlet容器来处理请求并生成响应。

如果finishResponse为true，则会调用response对象的finishResponse()方法和request对象的finishRequest()方法，将结果发送至客户端。最后，还会检查response的头信息“Connection”是否被设置为“close”，或者协议是否是HTTP 1.0，如果是，则将keepAlive设置为false，并回收request和response对象。

三、知识点总结

知识点	描述	关键代码示例
Request对象	封装HTTP请求信息，由多个类实现，外观类提供统一接口	`Request request = new HttpRequestImpl();` `RequestFacade facade = new RequestFacade(request);` `((HttpRequest) request).setMethod("GET");` `((HttpRequest) request).setRequestURI("/test");` `String method = facade.getMethod();` `String uri = facade.getRequestURI();`
Response对象	封装服务器响应信息，相关实现类构成特定继承和实现关系	- （主要体现在对象使用和设置响应信息过程中） -
HttpProcessor的process()方法	请求处理核心，执行解析连接、请求、请求头，处理异常等操作	`while (!stopped && ok && keepAlive) {` `finishResponse = true;` `request.setResponse(response);` `request.setStream(input);` `response.setStream(output);` `response.setRequest(request);` `if (ok) {` `parseConnection();` `parseRequest();` `if (!request.getRequest().getProtocol().startsWith("HTTP/0")) {` `parseHeaders();` `}` `}` `if (finishResponse) {` `response.finishResponse();` `request.finishRequest();` `output.flush();` `}` `if ("close".equals(response.getHeader("Connection"))) {` `keepAlive = false;` `}` `request.recycle();` `response.recycle();` `}`