HttpClient 内部机制：连接池、HTTP/2 与异步

一次请求经过的五层01

从公共 API 到 socket，大致经过「门面 → 交换 → 协议 → I/O → 池」五层。内部类名不是公共 API，升级 JDK 时可能变化；这里用它们建立职责地图，而不是让你去 import。

1. 调用 send / sendAsync，门面创建一次 exchange，确定目标地址、代理、TLS 配置。
2. 连接池查找可复用连接；没有可用连接时，由 SelectorManager 发起非阻塞 connect。
3. 协议层把请求编码为 HTTP/1.1 消息或 HTTP/2 HEADERS/DATA 帧；HTTP/2 在已有连接上开新 stream。
4. 响应头到达后，BodyHandler 决定如何消费 body；body 可能分多个事件到达。
5. 交换完成，连接归还池中；HTTP/2 连接保持打开，HTTP/1.1 连接按 keep-alive 复用。

连接池：按目标与配置分组02

连接池属于 client 实例，按目标地址、代理、TLS 配置等维度区分。HTTP/1.1 连接同一时刻只处理一个请求，顺序请求可以复用；并发请求可能需要多条连接。HTTP/2 连接可以同时承载多个 stream。

// 同一个 client、同一个 origin
client.send(request, HttpResponse.BodyHandlers.ofString()); // 建立连接 A
int before = PORTS.size();
for (int i = 0; i < 5; i++) {
    client.send(request, HttpResponse.BodyHandlers.ofString());
}
System.out.println(before + "->" + PORTS.size());

1->1

5 次顺序请求没有新增远端端口，说明连接被复用。这个实验只覆盖 HTTP/1.1 keep-alive；HTTP/2 的复用发生在 stream 层，服务端看到的仍然是一条 TCP 连接。

CompletableFuture 的完成与异常03

sendAsync 返回的 Future 在响应体被 BodyHandler 消费完后完成。thenApply 等依赖阶段默认在完成线程上执行；需要指定线程池时用 thenApplyAsync(fn, executor)。

CompletableFuture<String> body = client
        .sendAsync(request, HttpResponse.BodyHandlers.ofString())
        .thenApply(HttpResponse::body)
        .exceptionally(e -> "fallback: " + e.getClass().getSimpleName());

System.out.println(body.get(2, TimeUnit.SECONDS));

• send 直接抛 HttpTimeoutException；sendAsync 的 Future 异常完成，get() 的 cause 才是它。
• thenApply 里抛出的异常会让后续阶段异常完成；用 exceptionally / handle 做降级。
• 多个请求组合用 allOf 时，任何一个失败都会让 allOf 失败；需要逐个 future 处理异常，避免丢失其他结果。
• 不要在没有限流的情况下对下游发起无限并发；连接池和信号量才是并发上限。

超时：连接与整个交换分开设01

connectTimeout 只覆盖建立连接；HttpRequest.timeout 覆盖从请求发出到响应体完成的整个交换。两者都不设时，客户端可能无限等待。

HttpRequest slow = HttpRequest.newBuilder(URI.create(base + "/slow"))
        .timeout(Duration.ofMillis(100))
        .GET()
        .build();

try {
    client.send(slow, HttpResponse.BodyHandlers.ofString());
} catch (HttpTimeoutException e) {
    System.out.println("timeout=" + e.getClass().getSimpleName());
}

timeout=HttpTimeoutException

连接阶段超时通常是 HttpConnectTimeoutException（HttpTimeoutException 的子类），请求阶段超时是 HttpTimeoutException。异步调用要把 cause 取出来判断，不能只看最外层异常。

BodyHandler 与 BodyPublisher 的选择02

响应体用 BodyHandler 消费，请求体用 BodyPublisher 提供。选择时要考虑内存、流式和关闭责任。

HttpResponse<String> text = client.send(request,
        HttpResponse.BodyHandlers.ofString(StandardCharsets.UTF_8));

HttpResponse<Path> file = client.send(request,
        HttpResponse.BodyHandlers.ofFile(Path.of("body.bin")));

try (var lines = client.send(request, HttpResponse.BodyHandlers.ofLines()).body()) {
    lines.limit(10).forEach(System.out::println);
}

ofString() 会读取响应头 Content-Type 的 charset；没有时按 UTF-8。需要固定编码时显式传 StandardCharsets.UTF_8，不要依赖平台默认编码。

可运行：本地 HttpServer 全链路03

下面用 JDK 自带的 com.sun.net.httpserver.HttpServer 启动一个只支持 HTTP/1.1 的本地服务，验证同步、异步和连接复用。服务端按远端端口计数连接。

import com.sun.net.httpserver.HttpServer;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.net.URI;
import java.net.http.*;
import java.nio.charset.StandardCharsets;
import java.util.Set;
import java.util.concurrent.*;

public class HttpLocal {
    static final Set<Integer> PORTS = ConcurrentHashMap.newKeySet();

    public static void main(String[] args) throws Exception {
        HttpServer server = HttpServer.create(new InetSocketAddress("127.0.0.1", 0), 0);
        server.createContext("/hello", ex -> {
            PORTS.add(ex.getRemoteAddress().getPort());
            byte[] body = "hello".getBytes(StandardCharsets.UTF_8);
            ex.sendResponseHeaders(200, body.length);
            try (OutputStream os = ex.getResponseBody()) { os.write(body); }
        });
        server.start();

        String url = "http://127.0.0.1:" + server.getAddress().getPort() + "/hello";
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder(URI.create(url)).GET().build();

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

        String async = client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
                .thenApply(r -> r.statusCode() + ":" + r.body())
                .get(2, TimeUnit.SECONDS);
        System.out.println("async=" + async);

        int before = PORTS.size();
        for (int i = 0; i < 5; i++) {
            client.send(request, HttpResponse.BodyHandlers.ofString());
        }
        System.out.println("ports=" + before + "->" + PORTS.size());

        server.stop(0);
    }
}

client.version=HTTP_2
sync=200 hello HTTP_1_1
async=200:hello
ports=1->1

输出说明三件事：客户端期望 HTTP/2；本地服务只支持 HTTP/1.1，响应实际是 HTTP_1_1；同步与异步都成功；连续 5 次请求复用了同一条连接。

先猜再看：三个常见误解01

费曼自检：能否讲清管线02