How to use

HttpResponse$BodyHandlers

in

java.net.http

  private void upgradeToH2c(Target target){
    try {
      httpClient.send(HttpRequest.newBuilder()
          .method("options", HttpRequest.BodyPublishers.noBody())
          .uri(URI.create(target.url()))
          .build(),
          HttpResponse.BodyHandlers.discarding());
    } catch (IOException | InterruptedException e) {
      throw new RuntimeException(e);
    }
  }
}

      .send(this.httpRequest.build(), HttpResponse.BodyHandlers.ofString());
} catch (URISyntaxException | IOException | InterruptedException e) {
  LOG.error("Failed to execute HTTP request", e);

/**
 * Build http request, and send out sync.
 */
public AsyncResponseContext sendAsync() {
  Request request = build();
  // interceptors
  var interceptors = Lists.convert(client.interceptors(), InterceptorSupplier::get);
  for (var interceptor : interceptors) {
    request = interceptor.onRequest(request);
  }
  var finalRequest = request;
  var httpRequest = RequestUtils.toHttpRequest(finalRequest);
  var responseFuture = client.httpClient.sendAsync(httpRequest, HttpResponse.BodyHandlers.ofPublisher())
      .thenApply(r -> {
        var headers = Headers.ofHttpHeaders(r.headers());
        URL url;
        try {
          url = r.uri().toURL();
        } catch (MalformedURLException e) {
          throw new RequestsException(e);
        }
        return new SimpleAsyncResponseInfo(url, r.statusCode(), headers, r.body());
      });
  return new AsyncResponseContext(method, responseFuture, interceptors);
}

@Override
public Mono<ReactiveHttpResponse> executeRequest(ReactiveHttpRequest request) {
  HttpRequest.Builder requestBuilder = HttpRequest.newBuilder(request.uri())
      .method(request.method().toUpperCase(), provideBody(request));
  setUpHeaders(request, requestBuilder);
  if(requestTimeout > 0){
    requestBuilder = requestBuilder.timeout(Duration.ofMillis(requestTimeout));
  }
  if(tryUseCompression){
    requestBuilder = requestBuilder.setHeader(ACCEPT_ENCODING_HEADER, GZIP);
  }
  Java11ReactiveHttpResponse.ReactiveBodySubscriber bodySubscriber = new Java11ReactiveHttpResponse.ReactiveBodySubscriber();
  CompletableFuture<HttpResponse<Void>> response = httpClient.sendAsync(
      requestBuilder.build(), fromSubscriber(bodySubscriber));
  return Mono.fromFuture(response)
      .<ReactiveHttpResponse>map(resp -> {
        if(!resp.version().equals(httpClient.version())){
          throw new IllegalArgumentException("Incorrect response version:"+resp.version());
        }
        return new Java11ReactiveHttpResponse(resp, bodySubscriber.content(),
            returnPublisherClass, returnActualClass,
            jsonFactory, responseReader);
      })
      .onErrorMap(ex -> ex instanceof CompletionException
               && ex.getCause() instanceof java.net.http.HttpTimeoutException,
          ReadTimeoutException::new);
}

HttpResponse<InputStream> response;
try {
  response = client.httpClient.send(httpRequest, HttpResponse.BodyHandlers.ofInputStream());
} catch (IOException e) {
  throw new UncheckedIOException(e);