用Java Socket手撸了一个HTTP服务器

作为一个 Java 后端，提供 HTTP 服务可以说是基本技能之一了，但是你真的了解 HTTP 协议么？你知道知道如何手撸一个 HTTP 服务器么？Tomcat 的底层是怎么支持 HTTP 服务的呢？大名鼎鼎的 Servlet 又是什么东西呢，该怎么使用呢？

在初学 Java 时，Socket 编程是逃不掉的一章；虽然在实际业务项目中，使用这个的可能性基本为 0，但并不意味着不用学。本篇将主要介绍如何使用 Socket 来实现一个简单的 HTTP 服务器，提供常见的 get/post 请求支持，并在此过程中了解下 HTTP 协议。

I. HTTP 服务器从 0 到 1

既然我们的目标是借助 Socket 来搭建 HTTP 服务器，那么我们首先需要确认两点，一是如何使用 Socket；另一个则是 HTTP 协议如何解析数据；下面分别进行说明。

1. Socket 编程基础

我们这里主要是利用 ServerSocket 来绑定端口，提供 TCP 服务，基本使用姿势也比较简单，一般套路如下

创建 ServerSocket 对象，绑定监听端口
通过 accept() 方法监听客户端请求
连接建立后，通过输入流读取客户端发送的请求信息
通过输出流向客户端发送响应信息
关闭相关资源
对应的伪代码如下:

ServerSocket serverSocket = new ServerSocket(port, ip)
serverSocket.accept();
// 接收请求数据
socket.getInputStream();// 返回数据给请求方
out = socket.getOutputStream()
out.print(xxx)
out.flush();;// 关闭连接
socket.close()

具体的代码，我们前面的章节详细地讲过了，第一次来的小伙伴可以戳链接去学习一下。

2. HTTP 协议

ServerSocket 走的是 TCP 协议，HTTP 协议本身是在 TCP 协议之上的一层。

TCP 是一种面向连接的、可靠的、基于字节流的传输层协议。TCP 在两个网络节点之间提供了一条可靠的通信信道，确保数据在传输过程中不会丢失、重复或乱序。TCP 使用握手过程建立连接，通过确认和重传机制确保数据可靠传输，并使用流量控制和拥塞控制算法来优化网络性能。

HTTP 是一个用于在 Web 浏览器和 Web 服务器之间传输超文本、图像、视频和其他媒体资源的应用层协议。HTTP 使用请求-响应模型，即客户端（通常是 Web 浏览器）发送请求给服务器，服务器处理请求并返回响应。HTTP 协议定义了一组方法（如 GET、POST、PUT、DELETE 等），用于指定请求的类型和目的。此外，HTTP 协议还定义了一组状态代码（如 200、404、500 等），用于表示响应的结果。

HTTP 协议依赖于 TCP 协议来传输数据。当 Web 浏览器向 Web 服务器发送 HTTP 请求时，它首先使用 TCP 协议与服务器建立连接。一旦连接建立，HTTP 请求消息会被封装在 TCP 数据包中，然后通过 TCP 信道发送给服务器。服务器收到 TCP 数据包后，解包提取 HTTP 请求消息，处理请求并生成 HTTP 响应消息。最后，HTTP 响应消息被封装在 TCP 数据包中，并通过相同的 TCP 信道发送回客户端。客户端收到 TCP 数据包后，解包提取 HTTP 响应消息并显示给用户。
在这里插入图片描述
这幅图展示了客户端（Web 浏览器）与服务器（Web 服务器）之间的 HTTP 请求和响应，它们通过可靠的、面向连接的 TCP 连接进行数据传输。

好，再说回 HTTP 服务器这件事，最需要关注的无非两点：

请求消息

HTTP 请求消息由请求行（Request Line）、请求头（Request Headers）、空行（Empty Line）、请求体（Request Body，可选）几个部分组成。

①、请求行又包含三个部分，HTTP 方法（例如 GET, POST, PUT, DELETE 等）、请求的目标 URL（通常是相对 URL，但也可以是绝对 URL）、HTTP 版本（例如 HTTP/1.1 或 HTTP/2），这些部分用空格分隔，例如：

GET /index.html HTTP/1.1

②、请求头是一系列以键值对表示的元数据，用于描述请求的附加信息。每个请求头占一行，键和值之间用冒号（:）分隔。请求头包含诸如 Host、User-Agent、Content-Type、Content-Length、Accept 等信息。例如：

Host: www.tobebetterjavaer.com
User-Agent: Mozilla/5.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8

③、请求头和请求体之间有一个空行，表示请求头的结束。
④、对于某些 HTTP 方法（例如 POST、PUT 等），还可以在请求消息中包含请求体。请求体用于传输要发送给服务器的数据。请求体的格式和内容取决于 Content-Type 请求头的值。

例如，当提交 HTML 表单时，请求体可能如下所示：

username=恒二哥&password=123456

将这些部分放在一起，就构成了一个完整的 HTTP 请求消息：

POST /login HTTP/1.1
Host: Host: www.tobebetterjavaer.com
User-Agent: Mozilla/5.0
Content-Type: application/x-www-form-urlencoded
Content-Length: 29
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
username=恒二哥&password=123456

在这里插入图片描述

响应消息

一个典型的 HTTP 响应消息由三部分组成：状态行（Status Line）、响应头（Response Headers）、响应体（Response Body）。
在这里插入图片描述

上面两张图，可以让你对 HTTP 请求和响应有个直观映象，接下来开始抓重点。
不管是请求消息还是响应消息，都可以划分为三部分，这就为我们后面的处理简化了很多工作。

第一行：状态行
第二行到第一个空行：header（请求头/相应头）
剩下所有：正文

3. HTTP 服务器设计

接下来进入正题，基于 Socket 创建一个 HTTP 服务器，使用 Socket 基本没啥太大的问题，我们需要额外关注以下两点：

对请求数据进行解析
封装返回结果

a. 请求数据解析

注意📢，这些代码放在 HttpMessageParser 类中，随后会给出完整的代码。

@Data
public static class Request {/*** 请求方法 GET/POST/PUT/DELETE/OPTION...*/private String method;/*** 请求的uri*/private String uri;/*** HTTP版本*/private String version;/*** 请求头*/private Map<String, String> headers;/*** 请求参数相关*/private String message;
}

根据前面的 HTTP 协议介绍，解析过程如下，我们先看请求行的解析过程。

请求行，包含三个基本要素：请求方法 + URI + HTTP 版本，用空格进行分割，所以解析代码如下

/*** 根据标准的HTTP协议，解析请求行** @param reader* @param request*/
private static void decodeRequestLine(BufferedReader reader, Request request) throws IOException {String[] strs = StringUtils.split(reader.readLine(), " ");assert strs.length == 3;request.setMethod(strs[0]);request.setUri(strs[1]);request.setVersion(strs[2]);
}

**请求头的解析，**从第二行，到第一个空白行之间的所有数据，都是请求头；请求头的格式也比较清晰，形如 key:value, 具体实现如下：

最后就是正文的解析了，这一块需要注意一点，正文可能为空，也可能有数据；有数据时，我们要如何把所有的数据都取出来呢？

先看具体实现如下：

/*** 根据标注HTTP协议，解析正文** @param reader    输入流读取器，用于读取请求中的数据* @param request   Request 对象，表示 HTTP 请求* @throws IOException 当发生 I/O 错误时抛出*/
private static void decodeRequestMessage(BufferedReader reader, Request request) throws IOException {// 从请求头中获取 Content-Length，如果没有，则默认为 0int contentLen = Integer.parseInt(request.getHeaders().getOrDefault("Content-Length", "0"));// 如果 Content-Length 为 0，表示没有请求正文，直接返回。// 例如 GET 和 OPTIONS 请求通常不包含请求正文if (contentLen == 0) {return;}// 根据 Content-Length 创建一个字符数组来存储请求正文char[] message = new char[contentLen];// 使用 BufferedReader 读取请求正文reader.read(message);// 将字符数组转换为字符串，并将其设置为 Request 对象的 messagerequest.setMessage(new String(message));
}

注意上面我的使用姿势，首先是根据请求头中的Content-Type的值，来获得正文的数据大小，因此我们获取的方式是创建一个这么大的char[] 数组来读取流中所有数据，如果我们的数组比实际的小，则读不完；如果大，则数组中会有一些空的数据；

最后将上面的几个解析封装一下，完成 request 解析：

/*** HTTP 请求可以分为三部分：* 1. 请求行：包括请求方法、URI 和 HTTP 协议版本* 2. 请求头：从第二行开始，直到一个空行为止* 3. 消息正文：紧跟在空行后的所有内容，长度由请求头中的 Content-Length 决定** 本方法将 InputStream 中的 HTTP 请求数据解析为一个 Request 对象** @param reqStream  包含 HTTP 请求数据的输入流* @return           一个表示 HTTP 请求的 Request 对象* @throws IOException 当发生 I/O 错误时抛出*/
public static Request parse2request(InputStream reqStream) throws IOException {// 使用 BufferedReader 和 InputStreamReader 读取输入流中的数据BufferedReader httpReader = new BufferedReader(new InputStreamReader(reqStream, "UTF-8"));// 创建一个新的 Request 对象Request httpRequest = new Request();// 解析请求行并设置到 Request 对象中decodeRequestLine(httpReader, httpRequest);// 解析请求头并设置到 Request 对象中decodeRequestHeader(httpReader, httpRequest);// 解析消息正文并设置到 Request 对象中decodeRequestMessage(httpReader, httpRequest);// 返回解析后的 Request 对象return httpRequest;
}

接下来，是请求结果的封装，给一个简单的进行演示：

/*** Response 类表示一个 HTTP 响应，包括版本、状态码、状态信息、响应头和响应正文。*/
@Data
public static class Response {private String version;private int code;private String status;private Map<String, String> headers;private String message;
}/*** 根据给定的 Request 对象和响应字符串构建一个 HTTP 响应。** @param request   用于构建响应的 Request 对象* @param response  响应字符串* @return          一个表示 HTTP 响应的字符串*/
public static String buildResponse(Request request, String response) {// 创建一个新的 Response 对象，并设置版本、状态码和状态信息Response httpResponse = new Response();httpResponse.setCode(200);httpResponse.setStatus("ok");httpResponse.setVersion(request.getVersion());// 设置响应头Map<String, String> headers = new HashMap<>();headers.put("Content-Type", "application/json");headers.put("Content-Length", String.valueOf(response.getBytes().length));httpResponse.setHeaders(headers);// 设置响应正文httpResponse.setMessage(response);// 构建响应字符串StringBuilder builder = new StringBuilder();buildResponseLine(httpResponse, builder);buildResponseHeaders(httpResponse, builder);buildResponseMessage(httpResponse, builder);return builder.toString();
}/*** 构建响应行，包括版本、状态码和状态信息。** @param response      用于构建响应行的 Response 对象* @param stringBuilder 用于拼接响应字符串的 StringBuilder 对象*/
private static void buildResponseLine(Response response, StringBuilder stringBuilder) {stringBuilder.append(response.getVersion()).append(" ").append(response.getCode()).append(" ").append(response.getStatus()).append("\n");
}/*** 构建响应头。** @param response      用于构建响应头的 Response 对象* @param stringBuilder 用于拼接响应字符串的 StringBuilder 对象*/
private static void buildResponseHeaders(Response response, StringBuilder stringBuilder) {for (Map.Entry<String, String> entry : response.getHeaders().entrySet()) {stringBuilder.append(entry.getKey()).append(":").append(entry.getValue()).append("\n");}stringBuilder.append("\n");
}/*** 构建响应正文。** @param response      用于构建响应正文的 Response 对象* @param stringBuilder 用于拼接响应字符串的 StringBuilder 对象*/
private static void buildResponseMessage(Response response, StringBuilder stringBuilder) {stringBuilder.append(response.getMessage());
}

b. 请求任务 HttpTask

每个请求，单独分配一个任务来干这个事情，就是为了支持并发，对于 ServerSocket 而言，接收到了一个请求，那就创建一个 HttpTask 任务来实现 HTTP 通信。

那么这个 httptask 干啥呢？

从请求中捞数据
响应请求
封装结果并返回

/*** HttpTask 类实现了 Runnable 接口，用于处理一个 HTTP 请求。* 当在一个线程中执行时，该任务将处理一个 Socket 连接上的 HTTP 请求，* 并发送响应消息。*/
public class HttpTask implements Runnable {// 用于处理 HTTP 请求的 Socketprivate Socket socket;/*** 构造一个新的 HttpTask，用于处理指定的 Socket 连接。** @param socket  用于处理 HTTP 请求的 Socket*/public HttpTask(Socket socket) {this.socket = socket;}/*** 实现 Runnable 接口的 run 方法，用于处理 HTTP 请求并发送响应消息。*/@Overridepublic void run() {// 检查 socket 是否为 null，如果为 null 则抛出异常if (socket == null) {throw new IllegalArgumentException("socket can't be null.");}try {// 获取 Socket 的输出流，并创建一个 PrintWriter 对象OutputStream outputStream = socket.getOutputStream();PrintWriter out = new PrintWriter(outputStream);// 从 Socket 的输入流中解析 HTTP 请求HttpMessageParser.Request httpRequest = HttpMessageParser.parse2request(socket.getInputStream());try {// 根据请求结果进行响应，省略返回String result = null;// 根据请求和结果构建 HTTP 响应String httpRes = HttpMessageParser.buildResponse(httpRequest, result);// 将 HTTP 响应发送到客户端out.print(httpRes);} catch (Exception e) {// 如果发生异常，构建一个包含异常信息的 HTTP 响应String httpRes = HttpMessageParser.buildResponse(httpRequest, e.toString());out.print(httpRes);}// 刷新输出流，确保响应消息被发送out.flush();} catch (IOException e) {e.printStackTrace();} finally {// 关闭 Socket 连接try {socket.close();} catch (IOException e) {e.printStackTrace();}}}
}

c. HTTP 服务搭建

前面的基本上把该干的事情都干了，剩下的就简单了，创建ServerSocket，绑定端口接收请求，我们在线程池中跑这个 HTTP 服务

public class BasicHttpServer {// 创建一个单线程执行器，用于启动 HTTP 服务器private static ExecutorService bootstrapExecutor = Executors.newSingleThreadExecutor();// 创建一个线程池，用于处理来自客户端的 HTTP 请求private static ExecutorService taskExecutor;// 设置服务器监听的端口号private static int PORT = 8999;// 启动 HTTP 服务器的方法static void startHttpServer() {// 获取处理器可用核心数，用于设置线程池大小int nThreads = Runtime.getRuntime().availableProcessors();// 初始化线程池，设置线程池大小，队列大小和丢弃策略taskExecutor =new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(100),new ThreadPoolExecutor.DiscardPolicy());// 循环尝试启动服务器，如果启动失败，则等待10秒后重试while (true) {try {ServerSocket serverSocket = new ServerSocket(PORT);bootstrapExecutor.submit(new ServerThread(serverSocket));break;} catch (Exception e) {try {// 重试，等待 10 秒TimeUnit.SECONDS.sleep(10);} catch (InterruptedException ie) {Thread.currentThread().interrupt();}}}// 关闭启动执行器bootstrapExecutor.shutdown();}// HTTP 服务器主要任务类private static class ServerThread implements Runnable {// 保存传递给构造函数的 ServerSocket 实例private ServerSocket serverSocket;// 构造函数public ServerThread(ServerSocket s) throws IOException {this.serverSocket = s;}// 任务主体方法@Overridepublic void run() {while (true) {try {// 等待客户端连接Socket socket = this.serverSocket.accept();// 创建一个 HttpTask 实例，将 Socket 实例作为参数传递HttpTask eventTask = new HttpTask(socket);// 将 HttpTask 提交给 taskExecutor 执行taskExecutor.submit(eventTask);} catch (Exception e) {e.printStackTrace();try {// 如果发生异常，等待 1 秒后继续尝试TimeUnit.SECONDS.sleep(1);} catch (InterruptedException ie) {Thread.currentThread().interrupt();}}}}}
}