JavaThridProject
diff --git a/‎core/src/main/java/feign/AsyncClient.java‎
Lines changed: 101 additions & 0 deletions b/‎core/src/main/java/feign/AsyncClient.java‎
Lines changed: 101 additions & 0 deletions
@@ -0,0 +1,101 @@
+/**
+ * Copyright 2012-2020 The Feign Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package feign;
+
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
+import feign.Request.Options;
+
+/**
+ * Submits HTTP {@link Request requests} asynchronously, with an optional context.
+ */
+@Experimental
+public interface AsyncClient<C> {
+
+  /**
+   * Executes the request asynchronously. Calling {@link CompletableFuture#cancel(boolean)} on the
+   * result may cause the execution to be cancelled / aborted, but this is not guaranteed.
+   *
+   * @param request safe to replay
+   * @param options options to apply to this request
+   * @param requestContext - the optional context, for example for storing session cookies. The
+   *        client should update this appropriately based on the received response before completing
+   *        the result.
+   * @return a {@link CompletableFuture} to be completed with the response, or completed
+   *         exceptionally otherwise, for example with an {@link java.io.IOException} on a network
+   *         error connecting to {@link Request#url()}.
+   */
+  CompletableFuture<Response> execute(Request request, Options options, Optional<C> requestContext);
+
+  class Default<C> implements AsyncClient<C> {
+
+    private final Client client;
+    private final ExecutorService executorService;
+
+    public Default(Client client, ExecutorService executorService) {
+      this.client = client;
+      this.executorService = executorService;
+    }
+
+    @Override
+    public CompletableFuture<Response> execute(Request request,
+                                               Options options,
+                                               Optional<C> requestContext) {
+      final CompletableFuture<Response> result = new CompletableFuture<>();
+      final Future<?> future = executorService.submit(() -> {
+        try {
+          result.complete(client.execute(request, options));
+        } catch (final Exception e) {
+          result.completeExceptionally(e);
+        }
+      });
+      result.whenComplete((response, throwable) -> {
+        if (result.isCancelled()) {
+          future.cancel(true);
+        }
+      });
+      return result;
+    }
+  }
+
+  /**
+   * A synchronous implementation of {@link AsyncClient}
+   *
+   * @param <C> - unused context; synchronous clients handle context internally
+   */
+  class Pseudo<C> implements AsyncClient<C> {
+
+    private final Client client;
+
+    public Pseudo(Client client) {
+      this.client = client;
+    }
+
+    @Override
+    public CompletableFuture<Response> execute(Request request,
+                                               Options options,
+                                               Optional<C> requestContext) {
+      final CompletableFuture<Response> result = new CompletableFuture<>();
+      try {
+        result.complete(client.execute(request, options));
+      } catch (final Exception e) {
+        result.completeExceptionally(e);
+      }
+
+      return result;
+    }
+  }
+}