Java 如何将处理程序结果存储到JsonArray vertx中？

我面临一个问题，我无法将处理程序结果存储到Json数组中。每次数组为空时。我尝试使用Future，但仍然存在相同的问题，以下是我的代码：

 static void getCaraReferTypeDocBin(RoutingContext routingContext){
    String ids =  routingContext.request().getParam("ids");
    logger.debug(ids);
    String[] idsArray = ids.split(",");
    JsonArray caraRefTypeDocBin = new JsonArray();
    for (int i = 0; i <idsArray.length ; i++) {
        GET.getCaraTypeDocBin(Integer.parseInt(idsArray[i]), res->{
           if (res.succeeded()){
               logger.debug(res.result());
               caraRefTypeDocBin.add(res.result());
           }else{
               logger.debug(res.cause().getMessage());
           }
       });

    }
    logger.debug(caraRefTypeDocBin);
}

---

GET.getCaraTypeDocBin（）

异步运行，对吗？我认为这里面有一些耗时的东西，比如点击远程API？因此，循环将在毫秒内运行，启动所有请求，然后“

logger.debugs

”将发生，只有在那时回调才会开始执行

caraRefTypeDocBin.add（res.result（））

如果我是对的，您应该看到在空数组之前记录的结果。
在带有futures的async systems api中，应该这样编写：

private Future<String> loadFromDb() {
    Future<String> f = Future.future();
    //some internal loading from db
    String result = "fromDb";
    //when loading completes, pass it to future result
    f.complete(result);
    return f;
}

private Future loadFromDb（）{
Future f=Future.Future（）；
//一些来自数据库的内部加载
String result=“fromDb”；
//加载完成后，将其传递给将来的结果
f、 完成（结果）；
返回f；
}

以及如何使用：

private void handleSo(RoutingContext routingContext) {

    loadFromDb()
      .map(new Function<String, JsonArray>() {
          @Override
          public JsonArray apply(String fromDb) {
              //map to json
              return new JsonArray(...);
          }
      })
      .setHandler(
        new Handler<AsyncResult<JsonArray>>() {
            @Override
            public void handle(AsyncResult<JsonArray> result) {
                routingContext.response().end(result.result().toString());
            }
        }
      );
}

private void handleSo（路由上下文路由上下文）{
loadFromDb（）
.map（新函数（）{
@凌驾
公共JsonArray应用（来自DB的字符串）{
//映射到json
返回新的JsonArray（…）；
}
})
.setHandler(
新的处理程序。不知道如何使用回调样式的api实现它。但使用futures则没有问题：

private void handleSo(RoutingContext routingContext) {

        List<Future> futures = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            //make 10 async calls
            futures.add(loadFromDb()
              .map(new Function<String, JsonObject>() {
                  @Override
                  public JsonObject apply(String fromDb) {
                      return new JsonObject().put("data", fromDb);
                  }
              }));
        }
        CompositeFuture.all(futures)
          .map(new Function<CompositeFuture, JsonArray>() {
              @Override
              public JsonArray apply(CompositeFuture compositeFuture) {
                  JsonArray array = new JsonArray();
                  List<JsonObject> jsons = compositeFuture.result().list();
                  jsons.forEach(jsonObject -> array.add(jsonObject));
                  return array;

              }
          })
          .setHandler(new Handler<AsyncResult<JsonArray>>() {
              @Override
              public void handle(AsyncResult<JsonArray> res) {
                  routingContext.response().end(res.result().toString());
              }
          });
    }

private void handleSo（路由上下文路由上下文）{
列表期货=新的ArrayList（）；
对于（int i=0；i<10；i++）{
//进行10次异步调用
futures.add（loadFromDb（）
.map（新函数（）{
@凌驾
公共JsonObject应用（数据库中的字符串）{
返回新的JsonObject（）.put（“数据”，fromDb）；
}
}));
}
合成未来。全部（未来）
.map（新函数（）{
@凌驾
公共JsonArray应用（合成未来合成未来）{
JsonArray数组=新的JsonArray（）；
List jsons=compositeFuture.result（）.List（）；
forEach（jsonObject->array.add（jsonObject））；
返回数组；
}
})
.setHandler（新处理程序（）{
@凌驾
公共无效句柄（AsyncResult res）{
routingContext.response（）.end（res.result（）.toString（））；
}
});
}
感谢@Edward的响应，是的，它是异步运行的。我想将结果存储到JsonArray中，以便将其发送到客户端。您的异步api
getCaraTypeDocBin
实现错误。您可以显示它吗？感谢@zella的响应，我添加了
getCaraTypeDocBin
在问题中，谢谢@zella的解释，我从数据库中得到了完美的结果，我想要的是制作一个新的JsonArray，其中包含结果并将其发送到客户端。@HousseinO我没有注意：）我更新了答案
private void loadFromDb(Handler<String> handler) {
    String result = "fromDb";
    handler.handle(result);
}

 private void handleSo(RoutingContext routingContext) {
    loadFromDb(new Handler<String>() {
        @Override
        public void handle(String fromDb) {
            routingContext.response().end(new JsonArray(...).toString());
        }
    });
}

private void handleSo(RoutingContext routingContext) {

        List<Future> futures = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            //make 10 async calls
            futures.add(loadFromDb()
              .map(new Function<String, JsonObject>() {
                  @Override
                  public JsonObject apply(String fromDb) {
                      return new JsonObject().put("data", fromDb);
                  }
              }));
        }
        CompositeFuture.all(futures)
          .map(new Function<CompositeFuture, JsonArray>() {
              @Override
              public JsonArray apply(CompositeFuture compositeFuture) {
                  JsonArray array = new JsonArray();
                  List<JsonObject> jsons = compositeFuture.result().list();
                  jsons.forEach(jsonObject -> array.add(jsonObject));
                  return array;

              }
          })
          .setHandler(new Handler<AsyncResult<JsonArray>>() {
              @Override
              public void handle(AsyncResult<JsonArray> res) {
                  routingContext.response().end(res.result().toString());
              }
          });
    }