RxJava中VertX CompositeFuture的等价物

当您需要查询多个异步资源并在单个操作中使用它们时，VertX示例如下：

Future<HttpServer> httpServerFuture = Future.future();
httpServer.listen(httpServerFuture.completer());

Future<NetServer> netServerFuture = Future.future();
netServer.listen(netServerFuture.completer());

CompositeFuture.all(httpServerFuture, netServerFuture).setHandler(ar -> {
  if (ar.succeeded()) {
    // All servers started
  } else {
    // At least one server failed
  }
});

Future-httpServerFuture=Future.Future（）；
侦听（httpServerFuture.completer（））；
Future netServerFuture=Future.Future（）；
listen（netServerFuture.completer（））；
CompositeFuture.all（httpServerFuture，netServerFuture）.setHandler（ar->{
如果（ar.successed（））{
//所有服务器都已启动
}否则{
//至少有一台服务器出现故障
}
});

我们需要查询两个不同的数据库，然后在业务逻辑中使用结果，但流程是等效的

VertX/RxJava的等价物是什么

目前，人们通过在每次需要新变量时嵌套一个新的.flatMap（）调用来实现这一点。我觉得一定有更好的方法

---

实际上，我们不需要同时执行查询，但我们需要缓存两个结果，并以某种方式同时将它们传递给业务逻辑。

有很多方法可以做到这一点，但我尝试选择了一种与您的示例密切相关的方法：

@Override
public void start(Future<Void> startFuture) throws Exception {
    final HttpServer httpServer = vertx.createHttpServer();
    final Completable initializeHttpServer = httpServer.rxListen().toCompletable();

    final NetServer netServer = vertx.createNetServer();
    final Completable initializeNetServer = netServer.rxListen().toCompletable();

    initializeHttpServer.andThen(initializeNetServer)
        .subscribe(
            ()    -> { /* All servers started */ },
            error -> { /* At least one server failed */ }
        );
}

---

根据，

zip

允许您指定一系列反应类型（

Single

，

Observable

，等等），以及一个函数，以一次转换所有结果，中心思想是，在所有源发出一次（或多次，取决于反应类型）之前，它不会发出任何东西.

您可以使用

CompletableFuture.allOf（CompletableFuture…）：CompletableFuture

？这将是标准的Java 8。在VertX/RxJava的上下文中如何使用它？我不理解您所说的“在的上下文中”是什么意思，事实上，我不知道为什么Vert.x在迁移到Java 8之后仍然有自己的未来。但是您可以在异步Vertex回调中完成一个

CompletableFuture

s，然后运行

…allOf（futures.toArray（new CompletableFuture[0]）。然后应用（$->（成功时的操作））。例外情况下（t->（需要时执行异常操作））

这只是标准的

CompletableFuture

操作。考虑到所有这些都是异步的，只要您知道如何完成未来的工作，就应该能够对RxJava执行同样的操作。

    @Override
    public void start(Future<Void> startFuture) throws Exception {
        final Single<String> dbQuery1 = Single.fromCallable(() -> { return "db-query-result-1"; });
        final Single<String> dbQuery2 = Single.fromCallable(() -> { return "db-query-result-2"; });

        Single.zip(dbQuery1, dbQuery2, (result1, result2) -> {
            // handle the results from both db queries
            // (with Pair being a standard tuple-like class)
           return new Pair(result1, result2);
        })
            .subscribe(
                pair -> {
                    // handle the results
                },
                error -> {
                    // something went wrong
                }
            );
    }