Java 如何保存Vert.x WebClient结果并在方法中返回它

我在Java Vert.x项目中使用了一个方法，它使用

WebClient

调用另一个服务。我想将该调用的结果保存在

JsonObject

中并返回它。我假设我需要为此使用futures，但是当我运行

GetItemsService.retrieveItems

时，除了我的“在下面打印未来”消息之外，我在控制台中看到的都是

future{unresolved}

如何将

GetItemsManager.getItems

web客户端调用的结果保存在变量中

public class GetItemsManager {
    public Future<JsonObject> getItems(Future<JsonObject> future, Vertx vertx, RoutingContext routingContext) {
        WebClient webClient = WebClient.create(vertx);
        HttpServerResponse response = routingContext.response();
        JsonObject data = new JsonObject();
        response.setChunked(true);
        response.putHeader("content-type", "text/plain");
        response.putHeader("Access-Control-Allow-Origin", "*");
        webClient.post(80, Constants.API_URL, "/items")
            .as(BodyCodec.jsonArray())
            .putHeader("Accept", "application/json")
            .putHeader("Content-Type", "application/json")
            .putHeader("ugws7", Constants.SERVICES_URL)
            .sendJsonObject(new JsonObject().put("mutator", "*"), ar -> {
                if (ar.succeeded()) {
                    HttpResponse<JsonArray> result = ar.result();
                    JsonArray body = result.body();
                    data.put("data", body.getJsonObject(0));
                    future.complete(data);
                } else {
                    future.fail(new JsonObject().put("error", ar.cause().getMessage()).encode());
                }
            });
            return future;
    }
}

公共类GetItemsManager{
公共未来getItems（未来、Vertx Vertx、RoutingContext RoutingContext）{
WebClient-WebClient=WebClient.create（vertx）；
HttpServerResponse=routingContext.response（）；
JsonObject数据=新的JsonObject（）；
response.setChunked（true）；
响应.putHeader（“内容类型”、“文本/普通”）；
响应.putHeader（“访问控制允许原点”、“*”）；
webClient.post（80，Constants.API_URL，“/items”）
.as（BodyCodec.jsonArray（））
.putHeader（“接受”、“应用程序/json”）
.putHeader（“内容类型”、“应用程序/json”）
.putHeader（“ugws7”，常量.SERVICES\u URL）
.sendJsonObject（新JsonObject（）.put（“mutator”、“*”），ar->{
如果（ar.successed（））{
HttpResponse result=ar.result（）；
JsonArray body=result.body（）；
data.put（“data”，body.getJsonObject（0））；
未来。完成（数据）；
}否则{
future.fail（新的JsonObject（）.put（“error”，ar.cause（）.getMessage（））.encode（））；
}
});
回归未来；
}
}

---

公共类GetItemsService{
公共无效检索项（Vertx Vertx，RoutingContext RoutingContext）{
Future=Future.Future（）；
新建GetItemsManager（）.getItems（future、vertx、routingContext）；
字符串jsonObject=future.toString（）；
System.out.println（“下面打印未来”）；
System.out.println（jsonObject）；
}
}

更新

根据Peter的回答，我尝试用以下内容更新代码：

   public class GetItemsService {
    public void retrieveItems(Vertx vertx, RoutingContext routingContext) {
        Future<JsonObject> future = Future.future();
        new GeItemsManager().getItems(future, vertx, routingContext);
        String jsonObject;
        Future<JsonObject> f = future.setHandler(handler -> {
            handler.result();
        });
        System.out.println("Print future below");
        System.out.println(f);
    }
  }

公共类GetItemsService{
公共无效检索项（Vertx Vertx，RoutingContext RoutingContext）{
Future=Future.Future（）；
新建GeItemsManager（）.getItems（future、vertx、routingContext）；
字符串jsonObject；
Future f=Future.setHandler（处理程序->{
handler.result（）；
});
System.out.println（“下面打印未来”）；
系统输出打印ln（f）；
}
}

我仍然无法将调用的结果分配给变量（

f

）。

请尝试类似的操作

public class GetItemsService {
    public void retrieveItems(Vertx vertx, RoutingContext routingContext) {
        Future<JsonObject> future = Future.future();
        new GetLocationsManager().getItems(future, vertx, routingContext);
        future.setHandler(h ->{
            routingContext.response().end(h.result().encode());
        });
    }
}

公共类GetItemsService{
公共无效检索项（Vertx Vertx，RoutingContext RoutingContext）{
Future=Future.Future（）；
新建GetLocationsManager（）.getItems（future、vertx、routingContext）；
future.setHandler（h->{
routingContext.response（）.end（h.result（）.encode（））；
});
}
}

我希望这有助于我在代码中添加有用的注释

GetItemsManager

public class GetItemsManager {
public Future<JsonObject> getItems(Vertx vertx, RoutingContext routingContext) {
    //Note1: you can create the future here, no need to pass as a parameter
    Future<JsonObject> future = Future.future(); 
    ...
    webClient.post(80, Constants.API_URL, "/items")
        ...
        .sendJsonObject(new JsonObject().put("mutator", "*"), ar -> {
            if (ar.succeeded()) {
                ...
                future.complete(data);
            } else {
                future.fail(new JsonObject().put("error", ar.cause().getMessage()).encode());
            }
        });
        return future;
}
}

公共类GetItemsManager{
公共未来getItems（Vertx Vertx，RoutingContext RoutingContext）{
//注1：您可以在此处创建未来，无需作为参数传递
Future=Future.Future（）；
...
webClient.post（80，Constants.API_URL，“/items”）
...
.sendJsonObject（新JsonObject（）.put（“mutator”、“*”），ar->{
如果（ar.successed（））{
...
未来。完成（数据）；
}否则{
future.fail（新的JsonObject（）.put（“error”，ar.cause（）.getMessage（））.encode（））；
}
});
回归未来；
}
}

GetItemsService

public class GetItemsService {
    public void retrieveItems(Vertx vertx, RoutingContext routingContext) {
        new GetLocationsManager().getItems(vertx, routingContext) // returns Future<JsonObject>
            .setHandler(handler -> {
                //Note2: this codeblock is executed when your future is completed (or failed)
                if(handler.succeeded()){
                    //Note3: handler.result() contains the result from the getItems call (future.complete(data))
                    JsonObject items = handler.result();
                    doSomethingWithTheItems(items);
                    String itemsEncodedToString = items.encode();
                    // serve the response
                    routingContext.response().end(itemsEncodedToString);
                }else{
                    // serve error response
                    routingContext.response().end("something terrible happened" + handler.cause());
                }
        });
    }

    public void doSomethingWithTheItems(JsonObject items){
        // do something here with your items
    }
}

公共类GetItemsService{
公共无效检索项（Vertx Vertx，RoutingContext RoutingContext）{
新建GetLocationsManager（）.getItems（vertx，routingContext）//返回未来
.setHandler（处理程序->{
//注2：此代码块在未来完成（或失败）时执行
if（handler.successed（））{
//注3:handler.result（）包含getItems调用的结果（future.complete（data））
JsonObject items=handler.result（）；
不含任何物质（项目）的物质；
String itemsEncodedToString=items.encode（）；
//响应
routingContext.response（）.end（itemsEncodedToString）；
}否则{
//服务错误响应
routingContext.response（）.end（“发生了可怕的事情”+handler.cause（））；
}
});
}
公共无效DoSomethingWithitems（JsonObject项）{
//在这里用你的物品做点什么
}
}

//如果要执行其他异步方法，请选择2

public class GetItemsService {
    public void retrieveItems(Vertx vertx, RoutingContext routingContext) {
        new GetLocationsManager().getItems(vertx, routingContext);
            .compose(this::doSomethingAsyncWithTheItems)
            .setHandler(handler -> {
                if(handler.succeeded()){
                    //Note4: handler.result() contains the result from the doSomethingAsyncWithTheItems call (future.complete(...))
                    JsonObject didSomethingWithTheItems = handler.result();
                    routingContext.response().end(didSomethingWithTheItems.encode());
                }else{
                    // serve error response
                    routingContext.response().end("something terrible happened");
                }
        });
    }

    public Future<JsonObject> doSomethingAsyncWithTheItems(JsonObject items){
        Future<JsonObject> future = Future.future(); 
        otherAsyncCallThatReturnsAFuture.setHandler(handler -> {
            if(handler.succeeded()){
                future.complete(...)
            }else{
                future.fail(...)
            }
        })
        return future;
    }
}

公共类GetItemsService{
公共无效检索项（Vertx Vertx，RoutingContext RoutingContext）{
新建GetLocationsManager（）.getItems（vertx，routingContext）；
.compose（此：：doSomethingAsyncWithItems）
.setHandler（处理程序->{
if（handler.successed（））{
//注意4:handler.result（）包含doSomethingAsyncWithItems调用的结果（future.complete（…）
JsonObject在items=handler.result（）的情况下做了一些事情；
routingContext.response（）.end（使用items.encode（）进行了一些操作）；
}否则{
//服务错误响应
routingContext.response（）.end（“发生了可怕的事情”）；
}
});
}
公共未来DOSOMETHINGASYNCWITHITEMS（JsonObject项目）{
未来
public class GetItemsService {
    public void retrieveItems(Vertx vertx, RoutingContext routingContext) {
        new GetLocationsManager().getItems(vertx, routingContext);
            .compose(this::doSomethingAsyncWithTheItems)
            .setHandler(handler -> {
                if(handler.succeeded()){
                    //Note4: handler.result() contains the result from the doSomethingAsyncWithTheItems call (future.complete(...))
                    JsonObject didSomethingWithTheItems = handler.result();
                    routingContext.response().end(didSomethingWithTheItems.encode());
                }else{
                    // serve error response
                    routingContext.response().end("something terrible happened");
                }
        });
    }

    public Future<JsonObject> doSomethingAsyncWithTheItems(JsonObject items){
        Future<JsonObject> future = Future.future(); 
        otherAsyncCallThatReturnsAFuture.setHandler(handler -> {
            if(handler.succeeded()){
                future.complete(...)
            }else{
                future.fail(...)
            }
        })
        return future;
    }
}