深入理解HTTP持久连接：在同一Socket上发送多个请求的策略与实践

"GET /" + x + " HTTP/2\r\n"

HTTP/1.1 200 OK
Content-Length: 2
Content-Type: text/plain
Connection: close
Accept-Ranges: none

import java.io.*;
import java.net.Socket;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;

public class HttpClientRobust {

    private Socket socket;
    private PrintWriter output;
    private BufferedReader reader;
    private String hostname;
    private boolean keepAlive = true; // 假设初始期望保持连接

    public HttpClientRobust() throws IOException {
        URL url = new URL("http://192.168.178.56"); // 替换为你的ESP32 IP
        hostname = url.getHost();
        int port = 80;

        socket = new Socket(hostname, port);
        output = new PrintWriter(socket.getOutputStream());
        reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
    }

    public void sendAndReceive(String path) throws IOException, InterruptedException {
        if (!keepAlive) {
            System.out.println("Connection closed by server. Cannot send more requests on this socket.");
            return;
        }

        String request = String.format(
            "GET /%s HTTP/1.1\r\n"
            + "Host: %s\r\n"
            + "Connection: keep-alive\r\n" // 客户端请求保持连接
            + "\r\n",
            path, hostname
        );

        System.out.println("--- Sending Request ---");
        System.out.println(request);
        output.write(request);
        output.flush();

        System.out.println("--- Receiving Response ---");
        Map<String, String> headers = new HashMap<>();
        String line;
        int contentLength = -1;

        // 读取状态行
        line = reader.readLine();
        if (line == null) {
            System.out.println("Server closed connection prematurely.");
            keepAlive = false;
            return;
        }
        System.out.println(line); // 打印状态行

        // 读取并解析响应头
        while ((line = reader.readLine()) != null && !line.isEmpty()) {
            System.out.println(line);
            int colonIndex = line.indexOf(':');
            if (colonIndex > 0) {
                String headerName = line.substring(0, colonIndex).trim();
                String headerValue = line.substring(colonIndex + 1).trim();
                headers.put(headerName.toLowerCase(), headerValue);
            }
        }

        // 检查Connection头
        if ("close".equalsIgnoreCase(headers.get("connection"))) {
            keepAlive = false;
            System.out.println("Server requested to close connection.");
        }

        // 检查Content-Length
        if (headers.containsKey("content-length")) {
            try {
                contentLength = Integer.parseInt(headers.get("content-length"));
                System.out.println("Content-Length: " + contentLength);
                // 读取响应体
                char[] buffer = new char[contentLength];
                int bytesRead = 0;
                while (bytesRead < contentLength) {
                    int result = reader.read(buffer, bytesRead, contentLength - bytesRead);
                    if (result == -1) {
                        System.out.println("Error: Connection closed before reading full content.");
                        keepAlive = false;
                        break;
                    }
                    bytesRead += result;
                }
                System.out.println("Response Body: " + new String(buffer, 0, bytesRead));
            } catch (NumberFormatException e) {
                System.err.println("Invalid Content-Length header.");
            }
        } else {
            // 如果没有Content-Length，且不是chunked，且服务器没有明确关闭，
            // 那么读取到连接关闭为止，这在持久连接中不适用，
            // 应该通过Content-Length或Transfer-Encoding来判断结束。
            // 对于本例中服务器发送Connection: close的情况，可以继续读取直到null
            System.out.println("No Content-Length specified. Reading until connection closes or EOF.");
            StringBuilder responseBody = new StringBuilder();
            while (reader.ready() && (line = reader.readLine()) != null) { // reader.ready() 避免阻塞
                responseBody.append(line).append("\n");
            }
            if(responseBody.length() > 0) {
                System.out.println("Response Body: " + responseBody.toString().trim());
            }
        }

        if (!keepAlive) {
            close();
        }
    }

    public void close() throws IOException {
        if (socket != null && !socket.isClosed()) {
            socket.close();
            System.out.println("Socket closed.");
        }
    }

    public static void main(String[] args) throws IOException, InterruptedException {
        HttpClientRobust client = null;
        try {
            client = new HttpClientRobust();
            for (int i = 1; i <= 5; i++) {
                String x = i % 2 == 0 ? "on" : "off";
                client.sendAndReceive(x);
                if (!client.keepAlive) {
                    System.out.println("Server closed connection after " + i + " requests.");
                    break;
                }
                Thread.sleep(1000); // 每次请求之间稍作等待
            }
        } finally {
            if (client != null) {
                client.close();
            }
        }
    }
}