JDK自带的HttpClient，替代Apache的更优解？

那么问题来了：

✅ 如果你正在使用 Apache HttpClient，还需要继续依赖它吗？
✅ JDK 内置的 HttpClient 是否能满足企业级应用的需求？
✅ 在异步调用、高并发、响应式等不同场景下，哪个方案更合适？

🏄‍♀️JDK HttpClient响应式编程的优势

其实除了最基本的http请求支持外，JDK11在 HTTP 客户端的设计中全面采用了 Java 平台的 Reactive Streams 标准，使得它不仅支持常规的同步/异步请求，也支持背压控制的响应式数据流处理，这也是该客户端区别于传统库（如 Apache HttpClient）的重要进步之一。在以下几种场景时会有更高的性能：

📽大文件上传/下载（流式传输）

文件体积较大，无法一次性加载到内存。用响应式流将文件内容分片上传/下载，避免内存溢出。

示例（流式上传）

// 假设 filePublisher 是一个 Publisher<ByteBuffer>，按块读取文件内容
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://example.com/upload"))
    .POST(HttpRequest.BodyPublishers.fromPublisher(filePublisher))
    .build();

client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
      .thenAccept(response -> System.out.println("上传完成，状态码：" + response.statusCode()));

📽服务器推送（Server-Sent Events，SSE）

服务器持续推送事件流，客户端通过响应式订阅逐条处理数据。

示例（订阅响应体 Publisher）

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://example.com/sse-stream"))
    .build();

client.sendAsync(request, HttpResponse.BodyHandlers.ofLines())
      .thenAccept(response -> {
          response.body().subscribe(new Flow.Subscriber<>() {
              @Override
              public void onSubscribe(Flow.Subscription subscription) {
                  subscription.request(Long.MAX_VALUE); // 请求所有数据
              }
              @Override
              public void onNext(String item) {
                  System.out.println("接收事件：" + item);
              }
              @Override
              public void onError(Throwable throwable) {
                  throwable.printStackTrace();
              }
              @Override
              public void onComplete() {
                  System.out.println("事件流结束");
              }
          });
      });

📽实时日志流/监控数据流消费

实时拉取服务器日志或监控数据，逐条处理和展示。

示例（基于响应式流逐条处理）

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://example.com/logs"))
    .build();

client.sendAsync(request, HttpResponse.BodyHandlers.ofLines())
      .thenApply(HttpResponse::body)
      .thenAccept(bodyPublisher -> {
          bodyPublisher.subscribe(new Flow.Subscriber<String>() {
              @Override
              public void onSubscribe(Flow.Subscription subscription) {
                  subscription.request(1); // 控制背压，每次请求1条日志
              }

              @Override
              public void onNext(String item) {
                  System.out.println("日志条目：" + item);
                  // 请求下一条
                  subscription.request(1);
              }

              @Override
              public void onError(Throwable throwable) {
                  throwable.printStackTrace();
              }

              @Override
              public void onComplete() {
                  System.out.println("日志流结束");
              }
          });
      });

📽高吞吐量微服务间数据流交互

微服务间需要处理大量请求数据，响应式流可控制流速，防止服务被压垮。

关键点

使用 BodyPublishers.fromPublisher() 和 BodyHandlers.ofPublisher() 结合 Flow API，实现数据流的精细控制。

✅ 为什么你可以考虑替代传统 HttpClient？

以Apache HttpClient 为例，Apache HttpClient 功能丰富，但对于大多数日常调用 REST API 的需求而言，JDK 内置 HttpClient 足够强大、简洁并且更易维护。

📐Apache HttpClient VS JDK HttpClient

✏️编程方式对比

🔹 同步 GET 请求

✅ JDK HttpClient

HttpClient client = HttpClient.newHttpClient();

HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.example.com/data"))
        .build();

HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

🧱 Apache HttpClient

CloseableHttpClient client = HttpClients.createDefault();

HttpGet request = new HttpGet("https://api.example.com/data");
CloseableHttpResponse response = client.execute(request);

String result = EntityUtils.toString(response.getEntity());
System.out.println(result);

✅ JDK HttpClient 语法更简洁，原生支持自动关闭和异常包装。

🔸 异步请求处理

✅ JDK HttpClient（响应式、链式编程）

client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
      .thenApply(HttpResponse::body)
      .thenAccept(System.out::println)
      .exceptionally(e -> {
          e.printStackTrace();
          return null;
      });

🧱 Apache HttpAsyncClient（基于回调）

CloseableHttpAsyncClient asyncClient = HttpAsyncClients.createDefault();
asyncClient.start();

HttpGet request = new HttpGet("https://api.example.com/data");

asyncClient.execute(request, new FutureCallback<HttpResponse>() {
    public void completed(HttpResponse response) {
        System.out.println(response.getStatusLine());
    }

    public void failed(Exception ex) {
        ex.printStackTrace();
    }

    public void cancelled() {
        System.out.println("请求被取消");
    }
});

✅ JDK HttpClient 的异步模型更现代，天然适配 CompletableFuture 和响应式流。

📌特性与场景适配对比

1️⃣ 微服务客户端

• 推荐：✅ JDK HttpClient
• 原因：轻量、无需引入依赖、支持异步链式调用、内建 HTTP/2

2️⃣ 高并发调用（如网关、爬虫、多线程调用器）

• 推荐：✅ Apache HttpClient
• 原因：支持连接池配置、最大连接数限制、自定义重试和代理策略

3️⃣ 文件上传/下载、复杂表单处理

• 推荐：✅ Apache HttpClient
• 原因：提供 MultipartEntityBuilder 等高级工具类，封装更完善

4️⃣ Spring 应用或 Feign 客户端底层替换

• 推荐：仍建议使用 Apache（或更推荐 WebClient）

5️⃣ 开发命令行工具或内部 SDK

• 推荐：✅ JDK HttpClient
• 原因：无依赖、部署方便、异常处理一致性高

⚖️二者优劣对照

🔄 迁移方案：从 Apache HttpClient 迁移到 JDK HttpClient

🚧 初步评估

• 检查 HttpClient 使用集中度：是否封装在统一工具类中？
• 统计使用功能：是否大量使用拦截器、连接管理、自定义实体类型？
• 检查是否已切换到 JDK 11+，JDK 8 不支持 java.net.http.HttpClient

在选择 JDK 内置 HttpClient 还是 Apache HttpClient 时，除了功能差异外，使用成本和已有项目的迁移成本同样是关键考量因素。下面是几类典型场景的推荐方案：

1. 新项目或 JDK 11+ 的项目
   如果你正在开发一个新项目，或已有项目已升级到 JDK 11 及以上，推荐使用 JDK 内置的 HttpClient。它语法现代、零依赖、集成成本低，非常适合微服务调用、工具类 SDK、命令行工具等轻量应用。
2. 异步调用、响应式开发场景
   如果你使用 CompletableFuture、Reactor 或正在开发响应式服务，JDK HttpClient 的异步模型更自然，链式调用清晰，推荐使用 JDK 内置 HttpClient，可直接对接响应式链路，简化编程逻辑。
3. 已有项目大量使用 Apache HttpClient，且缺乏统一封装层
   如果你的项目中 Apache HttpClient 的使用已经深度嵌入业务代码，并且缺少统一封装，不建议立即切换到底层 JDK HttpClient。这类项目的迁移成本高、测试验证代价大。建议逐步在新功能中引入 JDK HttpClient，并通过封装层实现未来的平滑过渡。
4. 对连接池管理、请求重试、代理认证等有精细控制需求的场景
   如果你的应用涉及高并发请求、重试机制、代理设置、NTLM 等复杂认证，Apache HttpClient 提供更成熟的配置接口和可调节的连接管理能力，推荐继续使用 Apache HttpClient。
5. 需要支持文件上传或复杂 multipart 表单的接口
   JDK HttpClient 对 multipart/form-data 支持不友好，需要手动构造请求体。相比之下，Apache HttpClient 提供了 MultipartEntityBuilder 等工具类，更适合此类场景，因此 建议保留 Apache 实现。

可以直接看下图，帮你更好决策：

🔧 替代方案设计

💡 示例对比：POST JSON 请求

🔸 Apache HttpClient

HttpPost post = new HttpPost("https://example.com/api");
post.setHeader("Content-Type", "application/json");
post.setEntity(new StringEntity("{\"name\":\"shiker\"}", StandardCharsets.UTF_8));
CloseableHttpResponse response = client.execute(post);

🔸 JDK HttpClient

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://example.com/api"))
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString("{\"name\":\"shiker\"}"))
    .build();
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

💰 成本与迁移建议

✅ 推荐迁移路径

1. 封装层改造：将 Apache HttpClient 的封装接口替换为 JDK HttpClient 实现
2. 双实现阶段：允许新旧 HttpClient 并存，逐步替换调用点
3. 统一测试回归：重点验证超时处理、重试机制、错误回调是否保持一致

✍️ 结语

JDK 官方 HttpClient 的加入标志着 Java 网络通信 API 的一次重要革新。它为大多数 REST 调用、微服务通信、响应式编程提供了：

• ✅ 更轻的依赖管理
• ✅ 更清晰的异步模型
• ✅ 更现代的 API 设计

但在一些高级场景中，Apache HttpClient 仍具有不可替代的优势。

如果你是从零开始，优先使用 JDK 原生 HttpClient；

如果你在维护老项目，不妨先封装一层调用，再逐步替换底层实现，避免全量重构带来的高风险和高成本。