10+ reasons to NOT use JDK's HttpClient

public HttpRequestImpl(HttpRequestBuilderImpl builder) {
    // ...
    this.secure = uri.getScheme().toLowerCase(Locale.US).equals("https"); (1)
    // ...
}

public static HttpConnection getConnection(InetSocketAddress addr,
                                           HttpClientImpl client,
                                           HttpRequestImpl request,
                                           Version version) {
    // The default proxy selector may select a proxy whose  address is
    // unresolved. We must resolve the address before connecting to it.
    InetSocketAddress proxy = Utils.resolveAddress(request.proxy());
    HttpConnection c = null;
    boolean secure = request.secure();
    // ...

    if (!secure) {
        c = pool.getConnection(false, addr, proxy); (3)
        if (c != null && c.checkOpen() /* may have been eof/closed when in the pool */) {
            // ...
            return c;
        } else {
            return getPlainConnection(addr, proxy, request, client); (1)
        }
    } else {  // secure
        if (version != HTTP_2) { // only HTTP/1.1 connections are in the pool
            c = pool.getConnection(true, addr, proxy); (3)
        }
        if (c != null && c.isOpen()) {
            final HttpConnection conn = c;
            // ...
            return c;
        } else {
            // ...
            return getSSLConnection(addr, proxy, alpn, request, client); (2)
        }
    }
}

PlainHttpConnection(InetSocketAddress addr, HttpClientImpl client, String label) {
    super(addr, client, label);
    try {
        this.chan = SocketChannel.open(); (1)
        chan.configureBlocking(false);
        // ...
        chan.setOption(StandardSocketOptions.TCP_NODELAY, true);
        // wrap the channel in a Tube for async reading and writing
        tube = new SocketTube(client(), chan, Utils::getBuffer, label);
    } catch (IOException e) {
        throw new InternalError(e);
    }
}

val request = HttpRequest.newBuilder()
    .uri(URI.create("https://example.com"))
    .timeout(Duration.ofSeconds(5))
    .build();

private CompletableFuture<HttpResponse<T>>
responseAsync0(CompletableFuture<Void> start) {
    return start.thenCompose( v -> responseAsyncImpl()) (1)
                .thenCompose((Response r) -> {
                    // ...
                    return exch.readBodyAsync(responseHandler) (2)
                        // ...
}

private CompletableFuture<Response> responseAsyncImpl() {
    //...
        if (currentreq.timeout().isPresent()) {
            responseTimerEvent = ResponseTimerEvent.of(this);
            client.registerTimer(responseTimerEvent); (1)
        }
        // ...

        // 2. get response
        cf = exch.responseAsync() (2)
                 .thenCompose((Response response) -> {
                    HttpRequestImpl newrequest;
                    try {
                        // 3. apply response filters
                        newrequest = responseFilters(response);
                    } catch (Throwable t) {
                        IOException e = t instanceof IOException io ? io : new IOException(t);
                        exch.exchImpl.cancel(e);
                        return failedFuture(e);
                    }
                    // 4. check filter result and repeat or continue
                    if (newrequest == null) {
                        if (attempts.get() > 1) {
                            Log.logError("Succeeded on attempt: " + attempts);
                        }
                        return completedFuture(response);
                    } else {
                        cancelTimer();
                        this.response =
                            new HttpResponseImpl<>(currentreq, response, this.response, null, exch);
                        Exchange<T> oldExch = exch;
                        if (currentreq.isWebSocket()) {
                            // need to close the connection and open a new one.
                            exch.exchImpl.connection().close();
                        }
                        return exch.ignoreBody().handle((r,t) -> {
                            previousreq = currentreq;
                            currentreq = newrequest;
                            retriedOnce = false;
                            setExchange(new Exchange<>(currentreq, this));
                            return responseAsyncImpl();
                        }).thenCompose(Function.identity());
                    } })
                 .handle((response, ex) -> {
                    // 5. handle errors and cancel any timer set
                    cancelTimer(); (3)
                    if (ex == null) {
                        assert response != null;
                        return completedFuture(response);
                    }
                    // all exceptions thrown are handled here
                    CompletableFuture<Response> errorCF = getExceptionalCF(ex, exch.exchImpl);
                    if (errorCF == null) {
                        return responseAsyncImpl();
                    } else {
                        return errorCF;
                    } })
                 .thenCompose(Function.identity());
    // ...
}

@Override
public void handle() {
    //...
    // more specific, "request timed out", message when connected
    Exchange<?> exchange = multiExchange.getExchange();
    if (exchange != null) {
        ExchangeImpl<?> exchangeImpl = exchange.exchImpl;
        if (exchangeImpl != null) { (1)
            if (exchangeImpl.connection().connected()) {
                t = new HttpTimeoutException("request timed out");
            }
        }
    }
    if (t == null) { (2)
        t = new HttpConnectTimeoutException("HTTP connect timed out");
        t.initCause(new ConnectException("HTTP connect timed out"));
    }
    multiExchange.cancel(t); (3)
}