Vertx java-使用compose对代码排序

Question

我有一个逻辑，我需要将数据保存在两个表中（一对多）。我在我的Java中创建了两个方法，我正在尝试使用Vertx Future和compose来按顺序实现逻辑。但是我已经走了一半，不明白当第一个未来完成时如何实现compose。我的意思是第一个未来的代码运行anAsyncAction_1（料ToAdd）；，记录保存在数据库中，但是现在我如何在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

如果您只想编写这两个未来，可以简化实现，而无需使用CompositeFuture或Promise。

示例代码：

java prettyprint-override">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. Ansyncation\u 1内的异步DB调用将完成。返回的id将用于完成promise。这个promise将在第一个未来实现
2. future将使用id触发anAsyncAction\u 2。完成时的异步DB调用2将完成第二个future。在未来第二次完成后，将执行onComplete处理程序