如何在Java中处理Keep-Alive连接 Java实现持久连接的方法

// 开启Keep-Alive (默认通常就是true)
System.setProperty("http.keepAlive", "true");
// 设置每个目标主机允许的最大持久连接数
System.setProperty("http.maxConnections", "5"); // 例如，每个主机最多5个连接
// 设置Keep-Alive超时时间（单位：毫秒），但这个更多是客户端期望，服务器可能有自己的策略
System.setProperty("http.keepAliveDuration", "60000"); // 60秒

// 示例：使用HttpURLConnection
URL url = new URL("http://example.com/api/data");
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
try {
    connection.setRequestMethod("GET");
    // connection.setDoOutput(true); // 如果是POST/PUT请求
    // connection.getOutputStream().write(...);

    int responseCode = connection.getResponseCode();
    if (responseCode == HttpURLConnection.HTTP_OK) {
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()))) {
            String line;
            StringBuilder response = new StringBuilder();
            while ((line = reader.readLine()) != null) {
                response.append(line);
            }
            System.out.println("Response: " + response.toString());
        }
    } else {
        System.err.println("HTTP error code: " + responseCode);
    }
} finally {
    // 虽然不显式调用disconnect()，但关闭流是关键
    // disconnect()会关闭连接，但不会影响连接池的复用
    // connection.disconnect(); // 如果你确定不再复用此连接，可以调用
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;

public class ModernHttpClientExample {
    private static final HttpClient client = HttpClient.newBuilder()
            .version(HttpClient.Version.HTTP_1_1) // 明确使用HTTP/1.1以利用Keep-Alive
            .connectTimeout(Duration.ofSeconds(10)) // 连接超时
            .build();

    public static void main(String[] args) throws Exception {
        HttpRequest request1 = HttpRequest.newBuilder()
                .uri(URI.create("http://example.com/api/resource1"))
                .GET()
                .build();

        HttpRequest request2 = HttpRequest.newBuilder()
                .uri(URI.create("http://example.com/api/resource2"))
                .GET()
                .build();

        // 第一次请求
        HttpResponse<String> response1 = client.send(request1, HttpResponse.BodyHandlers.ofString());
        System.out.println("Response 1 Status: " + response1.statusCode());
        System.out.println("Response 1 Body: " + response1.body().substring(0, Math.min(response1.body().length(), 100)) + "...");

        // 第二次请求，如果服务器支持Keep-Alive，很可能会复用第一次的连接
        HttpResponse<String> response2 = client.send(request2, HttpResponse.BodyHandlers.ofString());
        System.out.println("Response 2 Status: " + response2.statusCode());
        System.out.println("Response 2 Body: " + response2.body().substring(0, Math.min(response2.body().length(), 100)) + "...");

        // 注意：HttpClient本身是线程安全的，可以复用同一个实例发送多个请求。
        // 它内部的连接池会处理Keep-Alive和连接复用。
    }
}

import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.util.EntityUtils;

import java.io.IOException;
import java.util.concurrent.TimeUnit;

public class ApacheHttpClientExample {
    public static void main(String[] args) throws IOException {
        // 创建连接池管理器
        PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager();
        // 设置最大连接数
        cm.setMaxTotal(200);
        // 设置每个路由（例如：同一个host:port）的最大连接数
        cm.setDefaultMaxPerRoute(20);

        // 创建HttpClient实例，绑定连接池管理器
        CloseableHttpClient httpClient = HttpClients.custom()
                .setConnectionManager(cm)
                // 可以设置Keep-Alive策略，例如：永远保持连接
                // .setKeepAliveStrategy((response, context) -> 60 * 1000) // 保持60秒
                .build();

        try {
            // 第一次请求
            HttpGet request1 = new HttpGet("http://example.com/api/resource1");
            try (CloseableHttpResponse response1 = httpClient.execute(request1)) {
                System.out.println("Response 1 Status: " + response1.getStatusLine());
                EntityUtils.consume(response1.getEntity()); // 确保消费响应体，释放连接
            }

            // 第二次请求
            HttpGet request2 = new HttpGet("http://example.com/api/resource2");
            try (CloseableHttpResponse response2 = httpClient.execute(request2)) {
                System.out.println("Response 2 Status: " + response2.getStatusLine());
                EntityUtils.consume(response2.getEntity()); // 确保消费响应体，释放连接
            }

            // 重要的：后台线程定期清理过期和空闲连接
            // 这通常在一个独立的线程中运行
            new Thread(() -> {
                try {
                    while (!Thread.currentThread().isInterrupted()) {
                        Thread.sleep(5000); // 每5秒清理一次
                        cm.closeExpiredConnections(); // 关闭过期连接
                        cm.closeIdleConnections(30, TimeUnit.SECONDS); // 关闭空闲超过30秒的连接
                    }
                } catch (InterruptedException ex) {
                    Thread.currentThread().interrupt();
                }
            }).start();

        } finally {
            // 关闭HttpClient，会关闭所有管理的连接
            httpClient.close();
            // 关闭连接池管理器
            cm.shutdown();
        }
    }
}