最简单的是如果你自己处理结果。您可以将onSuccess处理程序注册到您的future。这样，结果将被放入某种列表中，e。g. JsonArray。

List<Future> futures = //...list of futures

JsonArray results = new JsonArray();
futures.forEach(e -> e.onSuccess(h -> results.add(h)));

CompositeFuture.all(futures)
    .onComplete(ar -> {
        if(ar.failed()) {
            // successful elements are present in "results"
            routingContext.response().end(results.encode());
            return;
        }
        //... rest of your code
     });

您还可以查看rx-java库。这样的用例通常使用它可以更好地实现。

我会使用join操作而不是all，所以CompositeFuture将等待所有future完成，即使其中一个失败。否则，可能会发生与CompositeFuture的求值绑定将在所有异步调用完成之前发生。
然后，您可以在CompositeFuture中加入futures之前定义恢复步骤。

public static void main(String[] args) {
    List<String> inputs = List.of("1", "Terrible error", "2");

    List<Future> futures = inputs.stream()
        .map(i -> asyncAction(i)
            .recover(thr -> {
              // real recovery or just logging
              System.out.println("Bad thing happen: " + thr.getMessage());
              return Future.succeededFuture();
            }))
        .collect(Collectors.toList());

    CompositeFuture.join(futures)
        .map(CompositeFuture::list)
        .map(results -> results.stream()
            // filter out empty recovered future            
            .filter(Objects::nonNull)
            .collect(Collectors.toList()))
        .onSuccess(System.out::println);
  }

  static Future<String> asyncAction(final String input) {
    if ("Terrible error".equals(input)) {
      return Future.failedFuture(input);
    }
    return Future.succeededFuture(input);
  }

它将打印：

Bad thing happen: Terrible error
[1, 2]

使用all时，您可以简单地戳原始future以获得其结果：

List<Future> futures = //...list of futures

CompositeFuture.all(futures).onComplete(ar -> {
  if(ar.succeeded()){
    futures.forEach(fut -> log.info( fut.succeded() +" / " +_fut.result() ));
  }
} );

将成功存储到自己的数据存储中的问题是，数据存储需要是线程安全的，以防止竞争条件。因此，仅仅使用Java List或JsonArray并不是一个健壮的解决方案。解决这个问题的最简单和最少干扰的方法是在你的future周围创建一个 Package 器Future，它总是“成功”的，但是如果它“失败”，则用Throwable cause完成。通过这种方式，您可以按预期使用Vertx库的其余部分。
示例：

public Future<Object> wrapFuture(Future<Object> future) {
  Promise<Object> promise = Promise.promise();
  future.onComplete(asyncResult -> {
    if (asyncResult.succeeded()) {
      promise.complete(asyncResult.result());
    } else {
      promise.complete(cause);
    }
  });
}

public void myFunction() {
  List<Future> futures = new ArrayList<Future>();
  for (operationReturningAFuture: operations) {
    futures.add(wrapFuture(operationReturningAFuture()));
  }
  ComposititeFuture.join(futures).onComplete(asyncResult -> {
    List<Object> output = asyncResult.result().list();
    for (Object response : output) {
      if (response instanceof Throwable) {
        // this future failed
      } else {
        // this future succeeded
      }
    }
  });
}