Java 11 HttpClient批量高频发送GET请求的最优实现方式及相关问题咨询

嘿，针对你用Java 11 HttpClient开发的批量请求程序遇到的问题，我来给你详细分析下当前实现的问题，并给出更合理的优化方案～

你的现有逻辑存在几个核心问题，也是导致网络差时大量请求失败的主要原因：

• 固定休眠时间太僵硬：2500ms是拍脑袋的经验值，网络好的时候可能早就能拿到所有响应，白白浪费时间；网络差的时候又完全不够，导致大量请求还在pending就开始解析，自然拿不到结果。
• 缺少超时控制：没有给请求设置连接超时和读取超时，网络差的时候请求可能一直挂着，永远等不到响应，最终拖垮整个程序。
• 无异常处理机制：请求失败（比如连接拒绝、DNS解析失败）时会直接抛出未捕获异常，不仅影响当前请求，还可能导致整个批量任务崩溃。
• 未优化连接池：默认的HttpClient连接池配置可能无法支撑每分钟几百个请求的并发，容易出现连接耗尽、排队等待的情况。

推荐你基于异步请求+批量等待+合理超时+连接池配置的方式来优化，具体步骤如下：

1. 配置高性能的HttpClient实例 #

首先初始化一个带有合理参数的HttpClient，从根源上提升并发能力和稳定性：

HttpClient client = HttpClient.newBuilder()
        // 连接超时：5秒内没建立连接就算失败，避免无限等待连接
        .connectTimeout(Duration.ofSeconds(5))
        // 读取超时：建立连接后10秒内没拿到响应就算超时
        .responseTimeout(Duration.ofSeconds(10))
        // 配置连接池：根据请求量设置最大并发连接数，比如200
        .connectionPool(HttpClient.newConnectionPoolBuilder()
                .maxConnections(200)
                .build())
        // 可选：给幂等的GET请求添加重试逻辑（比如针对5xx异常重试2次）
        .addInterceptorFirst((HttpRequestInterceptor) (request, body, context) -> {
            // 这里可以自定义重试逻辑，比如通过context获取重试次数，超过阈值就停止
        })
        .build();

2. 批量发送异步请求，带超时等待所有完成 #

抛弃固定休眠，改用CompletableFuture.allOf()等待所有请求完成，同时设置整体超时，避免无限阻塞：

List<CompletableFuture<HttpResponse<String>>> futures = new ArrayList<>();

// 遍历所有待发送的请求，批量提交异步任务
for (HttpRequest request : requests) {
    CompletableFuture<HttpResponse<String>> future = client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
            // 单独处理每个请求的异常，避免一个请求失败影响整个批量任务
            .exceptionally(ex -> {
                System.err.println("请求失败: " + ex.getMessage());
                // 返回空响应或自定义错误响应，方便后续统一处理
                return null;
            });
    futures.add(future);
}

try {
    // 等待所有请求完成，设置整体超时（比如30秒，根据业务场景调整）
    CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
            .get(30, TimeUnit.SECONDS);
} catch (InterruptedException | ExecutionException | TimeoutException e) {
    System.err.println("批量请求超时或执行失败: " + e.getMessage());
}

// 统一解析所有响应
for (CompletableFuture<HttpResponse<String>> future : futures) {
    HttpResponse<String> response = future.getNow(null);
    if (response != null && response.statusCode() == 200) {
        // 解析JSON响应的逻辑
        String jsonBody = response.body();
        // ...业务处理
    } else {
        // 处理异常响应或失败的请求
        System.err.println("无效响应或请求失败");
    }
}

3. 可选：分批次控制并发量 #

如果担心一次性发送几百个请求压垮服务器或本地连接池，可以分批次发送，比如每次发50个，等待这批完成后再发下一批：

int batchSize = 50;
for (int i = 0; i < requests.size(); i += batchSize) {
    List<HttpRequest> batch = requests.subList(i, Math.min(i + batchSize, requests.size()));
    List<CompletableFuture<HttpResponse<String>>> batchFutures = new ArrayList<>();
    
    // 提交当前批次的请求
    for (HttpRequest request : batch) {
        CompletableFuture<HttpResponse<String>> future = client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
                .exceptionally(ex -> {
                    System.err.println("批次请求失败: " + ex.getMessage());
                    return null;
                });
        batchFutures.add(future);
    }
    
    // 等待当前批次完成
    try {
        CompletableFuture.allOf(batchFutures.toArray(new CompletableFuture[0]))
                .get(30, TimeUnit.SECONDS);
    } catch (Exception e) {
        System.err.println("批次处理失败: " + e.getMessage());
    }
    
    // 解析当前批次的响应...
}

非常不建议！同步发送是串行执行的，每个请求都要等待上一个请求完成才能发送，每分钟几百个请求的话，串行执行的时间会非常长，完全满足不了你“每分钟执行2-3次”的需求，吞吐量会大幅下降。

如果你的业务场景真的不需要高并发（比如请求量极小），同步实现方式很简单：

for (HttpRequest request : requests) {
    try {
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() == 200) {
            // 解析JSON响应
        }
    } catch (IOException | InterruptedException e) {
        System.err.println("同步请求失败: " + e.getMessage());
    }
}

但这种方式完全不适合你的需求，强烈建议用异步批量的优化方案。

内容的提问来源于stack exchange，提问作者cr0078