如何从CompletableFuture返回CompletableFuture

Question

我正在尝试实现一个通用的REST客户端，如下所示。我有自己的模型将HTTP响应表示为response T。这里T是服务调用的返回类型，它可能只是T或Ts列表。下面的代码不编译，我需要帮助。

@Override
    public <T> CompletableFuture<Response<T>> getAsync(UriOptions endpoint, Headers headers) {
        var builder = HttpRequest.newBuilder()
                .uri(endpoint.getAbsoluteUri())
                .GET();
        for (var entry : headers.getMessageHeaders().entrySet()) {
            builder.setHeader(entry.getKey(), entry.getValue());
        }
        var request = builder.build();
        var response = httpClient.sendAsync(request, HttpResponse.BodyHandlers.ofString());

        ObjectMapper objectMapper = new ObjectMapper();
        return response.thenComposeAsync(r ->
            try {
                 new Response<T>(
                        r.statusCode(),
                        HttpUtils.headersToMap(r.headers().map()),
                        objectMapper.readValue(r.body(), new TypeReference<T>() {
                        }),
                        HttpUtils.isSuccess(r.statusCode()), r.uri()
                );
            } catch (JsonProcessingException e) {
                throw new RuntimeException(e);
            }
        );
    }

public class Response<T> {
    private T content;
    private int statusCode;
    private boolean isSuccessful;
    private String statusDescription;
    private Exception exception;
    private Map<String, String> headers;
    private URI uri;

最终调用下面的方法，

@Test
    void getAsync() {
        // Arrange
        var baseUrl = settings.get("api.baseUri");
        var options = new UriOptions(baseUrl, "students/6277aade6f047803e8ae4bcf");
        var headers = new Headers(new HashMap<String, String>(), new HashMap<String, String>());

        // Act
        var response = restApiClient.<Student>getAsync(options, headers);

        // Assert
        response.thenAccept((r) ->
        {
            Assertions.assertEquals(200, r.getStatusCode());
        });
    }

Answer 1

回答“如何返回一个完整的未来”的问题

final CompletableFuture<String> future = CompletableFuture.supplyAsync(() => "42");
final CompletableFuture<Integer> intFuture = future.thenApply(Integer::parseInt);
// or future.thenApply(s -> Integer.parseInt(s));
// or future.thenApply(s -> { return Integer.parseInt(s); });

查看您的特定代码，thencomposasync的lambda中似乎存在语法错误（它由两个可完成的未来实例组成，因此其lambda需要返回另一个可完成的未来实例，而不是值本身）。

而且，由于它没有做任何昂贵的工作，因此异步转换值是一种过分的做法。一个简单的然后应用就可以了：

return response.thenApply(r -> {
    try {
         return new Response<T>(
                r.statusCode(),
                HttpUtils.headersToMap(r.headers().map()),
                objectMapper.readValue(r.body(), new TypeReference<T>() {}),
                HttpUtils.isSuccess(r.statusCode()), r.uri()
        );
    } catch (JsonProcessingException e) {
        throw new RuntimeException(e);
    }
});

如果您坚持使用thenCompose，那么您需要将结果包装在另一个CompletableFuture中：

return response.then(r -> {
    try {
         return CompletableFuture.completedFuture(new Response<T>(
                r.statusCode(),
                HttpUtils.headersToMap(r.headers().map()),
                objectMapper.readValue(r.body(), new TypeReference<T>() {}),
                HttpUtils.isSuccess(r.statusCode()), r.uri()
        ));
    } catch (JsonProcessingException e) {
        throw new RuntimeException(e);
    }
});