0

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

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();

    }
4

1 回答 1

1

如果您只想组合两个期货，则可以在不使用CompositeFutureor的情况下简化实现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();
  }

下面是顺序

  1. 内部的异步 DB 调用anAsyncAction_1将完成。返回的 id 将用于完成承诺。承诺将反过来完成第一个未来。
  2. anAsyncAction_2未来将通过 id触发。完成后的异步数据库调用 2 将完成第二个未来。发布第二个未来完成，onComplete处理程序将被执行。
于 2020-11-14T12:55:20.567 回答