Java从多个调用中收集CompletableFuture的结果

Question

我必须运行多个外部调用操作，然后以列表的形式获得结果。我决定使用completablefutureapi，而我准备的代码相当恶心：

示例：

public class Main {
    public static void main(String[] args) {
        String prefix = "collection_";

        List<CompletableFuture<User>> usersResult = IntStream.range(1, 10)
                .boxed()
                .map(num -> prefix.concat("" + num))
                .map(name -> CompletableFuture.supplyAsync(
                        () -> callApi(name)))
                .collect(Collectors.toList());

        try {
            CompletableFuture.allOf(usersResult.toArray(new CompletableFuture[usersResult.size()])).get();
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }

        List<User> users = usersResult //the result I need
                .stream()
                .map(userCompletableFuture -> {
                    try {
                        return userCompletableFuture.get();
                    } catch (InterruptedException | ExecutionException e) {
                        e.printStackTrace();
                    }
                    return null;
                })
                .filter(Objects::nonNull)
                .collect(Collectors.toList());
    }

    private static User callApi(String collection) {
        return new User(); //potentially time-consuming operation
    }
}

我有以下几个问题：

>

我可以避免在流中重复try-catch块吗？在流中我将CompletableFuture映射到User？

此代码是否可以不那么连续（如何避免等待所有的未来完成？）

这样做可以吗（所有的未来都将在流中解决吗？）：

public class Main {
    public static void main(String[] args) {
        String prefix = "collection_";

        List<User> usersResult = IntStream.range(1, 10)
                .boxed()
                .map(num -> prefix.concat("" + num))
                .map(name -> CompletableFuture.supplyAsync(
                        () -> callApi(name)))
                .filter(Objects::nonNull)
                .map(userCompletableFuture -> {
                    try {
                        return userCompletableFuture.get();
                    } catch (InterruptedException | ExecutionException e) {
                        e.printStackTrace();
                    }
                    return null;
                })
                .collect(Collectors.toList());
    }

    private static User callApi(String collection) {
        return new User(); //potentially time-consuming operation
    }
}

Answer 1

对于1.，您可以完全跳过ALLOF().GET()调用，因为您仍然在逐个等待所有未来。“

对于2.，您可以通过执行以下操作来简化try-catch：

• 使用exceptionaly()在将来直接处理异常；
• 使用join()而不是get()来避免检查异常（并且您知道不可能有异常）。

对于3.你不能真的减少它的顺序，因为你至少需要步骤：创建所有的未来，然后处理他们的结果。

如果您在一个流中执行所有操作，它将创建每个未来，然后在创建下一个之前立即等待它--这样您就会失去并行性。您可以使用并行流，但使用completablefutures并没有太大的好处。

所以最终的代码是：

List<CompletableFuture<User>> usersResult = IntStream.range(1, 10)
        .boxed()
        .map(num -> prefix.concat("" + num))
        .map(name -> CompletableFuture.supplyAsync(() -> callApi(name))
            .exceptionally(e -> {
                e.printStackTrace();
                return null;
            }))
        .collect(Collectors.toList());

List<User> users = usersResult
        .stream()
        .map(CompletableFuture::join)
        .filter(Objects::nonNull)
        .collect(Collectors.toList());

“注意，如果希望您的结果也是completablefuture ，则仍然需要allof()调用，例如。

final CompletableFuture<List<User>> result =
        CompletableFuture.allOf(usersResult.stream().toArray(CompletableFuture[]::new))
                .thenApply(__ -> usersResult
                        .stream()
                        .map(CompletableFuture::join)
                        .filter(Objects::nonNull)
                        .collect(Collectors.toList()));