Vertx java - 使用 compose 的排序代码

Question

我有一个逻辑需要将数据保存在两个表中（一对多）。我在我的 Java 中创建了两个方法，我正在尝试使用 Vertx Future 和 compose 来按顺序实现逻辑。但是我已经走了一半，不明白在第一个未来完成后如何实现组合。我的意思是代码运行第一个 future anAsyncAction_1(materialToAdd);，并且记录保存在数据库中，但现在我如何在 compose

public Future<Void> anAsyncAction_2(final SendToCompanyFromSupplier rawmaterialToAdd, Integer id)
{
    //code to get the id from the first future and save data in the table
}

下面是我的代码

public Future<Void> adddetails(final Supplier materialToAdd)
    {
        final Promise<Void> added = Promise.promise();
        
        Future<Integer> fut1 = anAsyncAction_1(materialToAdd);
        
        LOG.debug(" future.result()  "+fut1.result());
        
        fut1.compose((outcome) -> {
            LOG.debug(" future.result()  "+outcome);
             
        });

        CompositeFuture.all(fut1, fut2).onComplete(ar ->
        {
            System.out.println("BOTH OPERATION COMPLETED!! 1 " + ar.succeeded());
            try
            {
                System.out.println("BOTH OPERATION COMPLETED!! 2 " + ar.result().list());
                added.complete();
                System.out.println("BOTH OPERATION COMPLETED!!");
            } catch (Exception e)
            {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        });

        return added.future();

    }

Answer 1

如果你只想组合两个 futures，可以简化实现而不使用 CompositeFuture 或 Promise。

示例代码：

public Future<Void> adddetails(final Object materialToAdd) {
    Object rawMaterialToAdd = new Object();

    return anAsyncAction_1(materialToAdd).compose(i -> anAsyncAction_2(rawMaterialToAdd, i))
                                         .onComplete(ar -> {
                                           if (ar.succeeded()) {
                                             System.out.println("Both operations completed");
                                           } else {
                                             ar.cause()
                                               .printStackTrace();
                                           }
                                         });


  }

  private Future<Integer> anAsyncAction_1(Object materialToAdd) {
    Promise<Integer> promise = Promise.promise();
    Vertx.currentContext()
         .runOnContext(v -> promise.complete(1)); //Async Call. Replace with async DB call 1
    return promise.future();
  }

  public Future<Void> anAsyncAction_2(final Object rawmaterialToAdd, Integer id) {
    Promise<Void> promise = Promise.promise();
    Vertx.currentContext()
         .runOnContext(v -> {
           System.out.println("Id received:" + id);
           promise.complete();
         }); //Async Call. Replace it with the async DB call 2
    return promise.future();
  }

下面是顺序

anAsyncAction_1 内的异步数据库调用将完成。返回的 id 将用于完成承诺。承诺将反过来完成第一个未来。
以后用id触发anAsyncAction_2。完成后的异步数据库调用 2 将完成第二个未来。 Post 第二次未来完成 onComplete 处理程序将被执行。

Vertx java - 使用 compose 的排序代码

Vertx java - sequencing code using compose

vert.x

vertx-verticle

vertx-httpclient