#21 - ENH: Add HttpCall that allows client to choose async or sync processing of request

Author: rbygrave

client/src/main/java/io/avaje/http/client/DHttpCall.java

@@ -0,0 +1,127 @@
+package io.avaje.http.client;
+
+import java.net.http.HttpResponse;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Stream;
+
+class DHttpCall implements HttpCallResponse {
+
+  private final DHttpClientRequest request;
+
+  DHttpCall(DHttpClientRequest request) {
+    this.request = request;
+  }
+
+  @Override
+  public HttpCall<HttpResponse<Void>> asDiscarding() {
+    return new CallDiscarding();
+  }
+
+  @Override
+  public HttpCall<HttpResponse<String>> asString() {
+    return new CallString();
+  }
+
+  @Override
+  public <E> HttpCall<HttpResponse<E>> withHandler(HttpResponse.BodyHandler<E> bodyHandler) {
+    return new CallHandler<>(bodyHandler);
+  }
+
+  @Override
+  public <E> HttpCall<E> bean(Class<E> type) {
+    return new CallBean<>(type);
+  }
+
+  @Override
+  public <E> HttpCall<List<E>> list(Class<E> type) {
+    return new CallList<>(type);
+  }
+
+  @Override
+  public <E> HttpCall<Stream<E>> stream(Class<E> type) {
+    return new CallStream<>(type);
+  }
+
+  private class CallDiscarding implements HttpCall<HttpResponse<Void>> {
+    @Override
+    public HttpResponse<Void> execute() {
+      return request.asVoid();
+    }
+    @Override
+    public CompletableFuture<HttpResponse<Void>> async() {
+      return request.async().asDiscarding();
+    }
+  }
+
+  private class CallString implements HttpCall<HttpResponse<String>> {
+    @Override
+    public HttpResponse<String> execute() {
+      return request.asString();
+    }
+    @Override
+    public CompletableFuture<HttpResponse<String>> async() {
+      return request.async().asString();
+    }
+  }
+
+  private class CallBean<E> implements HttpCall<E> {
+    private final Class<E> type;
+    CallBean(Class<E> type) {
+      this.type = type;
+    }
+    @Override
+    public E execute() {
+      return request.bean(type);
+    }
+    @Override
+    public CompletableFuture<E> async() {
+      return request.async().bean(type);
+    }
+  }
+
+  private class CallList<E> implements HttpCall<List<E>> {
+    private final Class<E> type;
+    CallList(Class<E> type) {
+      this.type = type;
+    }
+    @Override
+    public List<E> execute() {
+      return request.list(type);
+    }
+    @Override
+    public CompletableFuture<List<E>> async() {
+      return request.async().list(type);
+    }
+  }
+
+  private class CallStream<E> implements HttpCall<Stream<E>> {
+    private final Class<E> type;
+    CallStream(Class<E> type) {
+      this.type = type;
+    }
+    @Override
+    public Stream<E> execute() {
+      return request.stream(type);
+    }
+    @Override
+    public CompletableFuture<Stream<E>> async() {
+      return request.async().stream(type);
+    }
+  }
+
+  private class CallHandler<E> implements HttpCall<HttpResponse<E>> {
+    private final HttpResponse.BodyHandler<E> handler;
+    CallHandler(HttpResponse.BodyHandler<E> handler) {
+      this.handler = handler;
+    }
+    @Override
+    public HttpResponse<E> execute() {
+      return request.withHandler(handler);
+    }
+    @Override
+    public CompletableFuture<HttpResponse<E>> async() {
+      return request.async().withHandler(handler);
+    }
+  }
+}

client/src/main/java/io/avaje/http/client/DHttpClientRequest.java

@@ -289,6 +289,11 @@ public HttpAsyncResponse async() {
     return new DHttpAsync(this);
   }
 
+  @Override
+  public HttpCallResponse call() {
+    return new DHttpCall(this);
+  }
+
   @Override
   public HttpClientResponse HEAD() {
     httpRequest = newHead(url.build());

client/src/main/java/io/avaje/http/client/HttpCall.java

@@ -0,0 +1,21 @@
+package io.avaje.http.client;
+
+import java.util.concurrent.CompletableFuture;
+
+/**
+ * Allows for executing the request asynchronously or synchronously.
+ *
+ * @param <E> The type of response
+ */
+public interface HttpCall<E> {
+
+  /**
+   * Execute the request returning the result.
+   */
+  E execute();
+
+  /**
+   * Execute the request asynchronously.
+   */
+  CompletableFuture<E> async();
+}

client/src/main/java/io/avaje/http/client/HttpCallResponse.java

@@ -0,0 +1,126 @@
+package io.avaje.http.client;
+
+import java.net.http.HttpResponse;
+import java.util.List;
+import java.util.stream.Stream;
+
+/**
+ * Allows the client code to choose to execute the request asynchronously
+ * or synchronously.
+ */
+public interface HttpCallResponse {
+
+  /**
+   * Process discarding response body as {@literal HttpResponse<Void>}.
+   *
+   * <pre>{@code
+   *
+   *   HttpCall<HttpResponse<Void>> call =
+   *     clientContext.request()
+   *       .path("hello/world")
+   *       .GET()
+   *       .call().asDiscarding();
+   *
+   * }</pre>
+   *
+   * @return The HttpCall to allow sync or async execution
+   */
+  HttpCall<HttpResponse<Void>> asDiscarding();
+
+  /**
+   * Process as String response body {@literal HttpResponse<String>}.
+   *
+   * <pre>{@code
+   *
+   *   HttpCall<HttpResponse<String>> call =
+   *     clientContext.request()
+   *       .path("hello/world")
+   *       .GET()
+   *       .call().asString();
+   *
+   * }</pre>
+   *
+   * @return The HttpCall to allow sync or async execution
+   */
+  HttpCall<HttpResponse<String>> asString();
+
+  /**
+   * Call using any given {@code HttpResponse.BodyHandler}.
+   * <pre>{@code
+   *
+   *    HttpCall<E> call = clientContext.request()
+   *       .path("hello/lineStream")
+   *       .GET()
+   *       .call().withHandler(HttpResponse.BodyHandler<E> ...);
+   * }</pre>
+   *
+   * @param bodyHandler The response body handler to use
+   * @return The HttpCall to allow sync or async execution
+   */
+  <E> HttpCall<HttpResponse<E>> withHandler(HttpResponse.BodyHandler<E> bodyHandler);
+
+  /**
+   * A bean response to execute async or sync.
+   * <p>
+   * If the HTTP statusCode is 300 or above a HttpException is throw which contains
+   * the HttpResponse. This is the cause in the CompletionException. Redirects are
+   * by default followed apart from HTTPS to HTTP.
+   *
+   * <pre>{@code
+   *
+   *  HttpCall<HelloDto> call =
+   *    clientContext.request()
+   *       ...
+   *       .POST()
+   *       .call().bean(HelloDto.class);
+   *
+   * }</pre>
+   *
+   * @param type The bean type to convert the content to
+   * @return The HttpCall to allow sync or async execution
+   */
+  <E> HttpCall<E> bean(Class<E> type);
+
+  /**
+   * Process expecting a list of beans response body (typically from json content).
+   * <p>
+   * If the HTTP statusCode is 300 or above a HttpException is throw which contains
+   * the HttpResponse. This is the cause in the CompletionException. Redirects are
+   * by default followed apart from HTTPS to HTTP.
+   *
+   * <pre>{@code
+   *
+   *  HttpCall<List<HelloDto>> call =
+   *    clientContext.request()
+   *       ...
+   *       .GET()
+   *       .call().list(HelloDto.class);
+   * }</pre>
+   *
+   * @param type The bean type to convert the content to
+   * @return The HttpCall to execute sync or async
+   */
+  <E> HttpCall<List<E>> list(Class<E> type);
+
+  /**
+   * Process expecting a stream of beans response body (typically from json content).
+   * <p>
+   * If the HTTP statusCode is 300 or above a HttpException is throw which contains
+   * the HttpResponse. This is the cause in the CompletionException. Redirects are
+   * by default followed apart from HTTPS to HTTP.
+   *
+   * <pre>{@code
+   *
+   *  HttpCall<Stream<HelloDto>> call =
+   *    clientContext.request()
+   *       ...
+   *       .GET()
+   *       .call().stream(HelloDto.class);
+   * }</pre>
+   *
+   * @param type The bean type to convert the content to
+   * @return The HttpCall to execute sync or async
+   */
+  <E> HttpCall<Stream<E>> stream(Class<E> type);
+
+}

client/src/main/java/io/avaje/http/client/HttpClientResponse.java

@@ -17,6 +17,12 @@ public interface HttpClientResponse {
    */
   HttpAsyncResponse async();
 
+  /**
+   * Return a HttpCall which allows either sync or async
+   * execution of the request.
+   */
+  HttpCallResponse call();
+
   /**
    * Returning the response using the given response reader.
    *