Question

我试图理解Java 8中的CompletableFuture。作为它的一部分，我试图进行一些REST调用以巩固我的理解。我正在使用该库进行REST调用：https://github.com/AsyncHttpClient/async-http-client。

请注意，该库为GET调用返回一个Response对象。

以下是我要执行的操作：

调用此提供用户列表的URL：https://jsonplaceholder.typicode.com/users
使用GSON将响应转换为用户对象列表。
遍历列表中的每个User对象，获取userID，然后从以下URL获取用户发表的帖子列表：https://jsonplaceholder.typicode.com/posts?userId=1
使用GSON将每个帖子回复转换为帖子对象。

构建UserPost对象的集合，每个对象都有一个User Object和用户发表的帖子列表。

public class UserPosts {

private final User user;
private final List<Post> posts;

public UserPosts(User user, List<Post> posts) {
    this.user = user;
    this.posts = posts;
}

@Override
public String toString() {
    return "user = " + this.user + " \n" + "post = " + posts+ " \n \n";
}

}

我目前将其实现如下：

package com.CompletableFuture;

import java.util.List;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Future;
import java.util.function.Function;
import java.util.stream.Collectors;

import org.asynchttpclient.Response;

import com.http.HttpResponse;
import com.http.HttpUtil;
import com.model.Post;
import com.model.User;
import com.model.UserPosts;

/**
 * Created by vm on 8/20/18.
 */

class UserPostResponse {
    private final User user;
    private final Future<Response> postResponse;

    UserPostResponse(User user, Future<Response> postResponse) {
        this.user = user;
        this.postResponse = postResponse;
    }

    public User getUser() {
        return user;
    }

    public Future<Response> getPostResponse() {
        return postResponse;
    }
}

public class HttpCompletableFuture extends HttpResponse {
    private Function<Future<Response>, List<User>> userResponseToObject = user -> {
        try {
            return super.convertResponseToUser(Optional.of(user.get().getResponseBody())).get();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    };
    private Function<Future<Response>, List<Post>> postResponseToObject = post -> {
        try {
            return super.convertResponseToPost(Optional.of(post.get().getResponseBody())).get();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    };

    private Function<UserPostResponse, UserPosts> buildUserPosts = (userPostResponse) -> {
        try {
            return new UserPosts(userPostResponse.getUser(), postResponseToObject.apply(userPostResponse.getPostResponse()));
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    };

    private Function<User, UserPostResponse> getPostResponseForUser = user -> {
        Future<Response> resp = super.getPostsForUser(user.getId());
        return new UserPostResponse(user, resp);
    };

    public HttpCompletableFuture() {
        super(HttpUtil.getInstance());
    }

    public List<UserPosts> getUserPosts() {

        try {
            CompletableFuture<List<UserPosts>> usersFuture = CompletableFuture
                    .supplyAsync(() -> super.getUsers())
                    .thenApply(userResponseToObject)
                    .thenApply((List<User> users)-> users.stream().map(getPostResponseForUser).collect(Collectors.toList()))
                    .thenApply((List<UserPostResponse> userPostResponses ) -> userPostResponses.stream().map(buildUserPosts).collect(Collectors.toList()));

            List<UserPosts> users = usersFuture.get();
            System.out.println(users);
            return users;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

}

但是，我不确定我这样做的方式是否正确。更具体地说，在userResponseToObject和postResponseToObject函数中，我在Future上调用get()方法，该方法将被阻塞。

是否有更好的方法来实现这一点？

Answer 1

如果您打算使用CompletableFuture，则应使用async-http-client库中的ListenableFuture。 ListenableFuture可以转换为CompletableFuture。

使用CompletableFuture的好处是您可以编写处理Response对象的逻辑，而不必了解任何有关期货或线程的知识。假设您编写了以下4种方法。 2个发出请求和2个解析响应：

ListenableFuture<Response> requestUsers() {

}

ListenableFuture<Response> requestPosts(User u) {

}

List<User> parseUsers(Response r) {

}

List<UserPost> parseUserPosts(Response r, User u) {

}

现在，我们可以编写一个非阻塞方法来检索给定用户的帖子：

CompletableFuture<List<UserPost>> userPosts(User u) {
    return requestPosts(u)
        .toCompletableFuture()
        .thenApply(r -> parseUserPosts(r, u));
}

以及一种阻止所有用户阅读所有帖子的阻止方法：

List<UserPost> getAllPosts() {
    // issue all requests
    List<CompletableFuture<List<UserPost>>> postFutures = requestUsers()
            .toCompletableFuture()
            .thenApply(userRequest -> parseUsers(userRequest)
                    .stream()
                    .map(this::userPosts)
                    .collect(toList())
            ).join();


    // collect the results
    return postFutures.stream()
            .map(CompletableFuture::join)
            .flatMap(List::stream)
            .collect(toList());
}

Answer 2

根据要用于管理阻止响应的策略，您可以至少探索以下实现：

1）调用带有超时的CompletableFuture类的重载方法get：

List<UserPosts> users = usersFuture.get(long timeout, TimeUnit unit);

从文档中：

如果有必要，最多等待给定时间以等待此未来完成，然后返回其结果（如果有）。

2）使用替代方法getNow：

列出用户= usersFuture.getNow（T valueIfAbsent）;

在以下情况下返回结果值（或引发任何遇到的异常）完成，否则返回给定的valueIfAbsent。

3）使用CompletableFuture而不是Future，可以手动调用 complete 强制强制解锁 get ：

usersFuture.complete("Manual CompletableFuture's Result")

针对子请求的CompletableFuture

2 个答案: