我有一种情况,我调用外部 API A 并使用它的响应来提供 API B 的请求并调用它,然后将响应返回给 API A 的调用者。如下所示
method(){
response = call API A
}
method_for_API_A(){
handler() ->{
API_B
}
return response;
}
method_for_API_B(){
//code to call API B
}
我在这里面临的是 API A 方法正在返回响应,而无需等待 B 的响应。
我检查了 vert.x 的 executeBlocking 方法,还尝试使用“阻塞队列”但无法实现我打算做的事情。 有人可以指导我正确的做法吗?提前致谢。
编辑:只是为了解释确切的场景
Class MyClass{
public Response method_A (Request request){
String respFromApiA = Call_API_A(request) ; // STEP 1
Response respFromApiB = Call_API_B(request, respFromApiA); // STEP 2
Print(respFromApiB) // PRINT FINAL Response
return respFromApiB; // STEP 3
}
String Call_API_A(Request request){
// Implementation
Print(string); // PRINT API A response
return string
}
Response Call_API_B(Response response){
// Implementation
Print(response); // PRINT API B response
return response;
}
}
我在 Java 中使用 vert.x 框架。 现在执行期间发生的事情是,流程来到第 1 步,启动 API A 调用。转到步骤 2(无需等待“respFromApiA”)并调用 API B(最终失败,因为 respFromApiA 为 NULL)。最后流程转到第 3 步并从这里返回。 (无需等待 API A 和 API B 的结果)。 如果我们看到打印顺序,它将是这样的
PRINT FINAL Response
PRINT API A response
PRINT API B response
我想达到什么目的?
Wait for API A response.
Make call to API B. Wait for API B response.
Return response got from API B.
希望这次能说清楚。如果您需要进一步的输入,请告诉我。
最佳答案
Vert.x 是高度异步的。大多数操作实际上会立即返回,但它们的结果将可用于 Handler
在稍后的时间点。到目前为止,一切都很好。如果我理解正确的话,你需要调用 B
在Handler
的 A
.在这种情况下 A
需要完成,结果将在您调用 B
之前可用:
callA(asyncResultA -> {
System.out.println("Result A: " + asyncResultA.result());
callB(asyncResultB -> {
System.out.println("Result B:" + asyncResultB.result());
});
});
但是您正在尝试的是使某些异步同步。您不能也不应该尝试在主程序流中提供异步结果——那是行不通的。
String respFromApiA = Call_API_A(request); // STEP 1
Response respFromApiB = Call_API_B(request, respFromApiA); // STEP 2
Print(respFromApiB); // PRINT FINAL Response
return respFromApiB; // STEP 3
Call_API_A
不能真正返回结果,因为它是异步计算的。结果仅适用于 Handler
的 Call_API_A
(见我上面的例子)。同样适用于 Call_API_B
– 所以你不能返回 Call_API_B
的结果.您类(class)的调用者还需要使用 Handler
来调用您的类(class).
现在一些附加信息。在您的情况下,您会遇到多个异步结果相互依赖的问题。 Vert.x 提供了一种更方便的方式来处理异步结果——所谓的 Futures
. Future
(有时称为 Promise
但在 Java 世界中它们称为 Future
)是异步调用结果的占位符。在 documentation 中阅读有关它们的信息.
用Future
你可以这样做:
Future<...> callAFuture = Future.future();
callA(asyncResultA -> {
if (asyncResultA.succeeded()) {
System.out.println("A finished!");
callAFuture.complete(asyncResultA.result());
} else {
callAFuture.fail(asyncResultA.cause());
}
});
因此,与其尝试返回 B
的异步结果,不如尝试返回异步结果以同步方式,您应该返回 Future
所以你类(class)的被调用者可以注册两个A
的异步结果和 B
.
希望对您有所帮助。
编辑: future 作为返回值
假设您要包装 callA
with 所以你可以使用 Future
.你可以这样做:
public Future<String> doSomethingAsync() {
Future<String> callAFuture = Future.future();
// do the async stuff
callA(asyncResultA -> {
if (asyncResultA.succeeded()) {
System.out.println("A finished!");
callAFuture.complete(asyncResultA.result());
} else {
callAFuture.fail(asyncResultA.cause());
}
});
// return Future with the asyncResult of callA
return callAFuture;
}
这个函数的调用者可以像这样使用 Future:
Future<String> doSomethingFuture = doSomethingAsync();
doSomethingFuture.setHandler(somethingResult -> {
// ... doSomethingAsync finished
});
也可以组成多个Future
如果您想同时执行它们但它们不相互依赖:
CompositeFuture.all(futureA, futureB).setHandler(connections -> {
// both Futures completed
});
如果您在像 Vert.x 这样的异步环境中工作,大部分时间您会使用 soon-to-be-available-result aka Future
.而在 Handler
的 Future
你经常做另一个异步调用。你包装一个 Future
用Future
像 callB
的例子在callA
的 Handler
.
您将如何返回 Future
的异步结果?作为 HTTP 响应?像这样:
router.route("/").handler(routingContext -> {
HttpServerResponse response = routingContext.response();
Future<String> future = doSomethingAsync();
future.setHandler(somethingResult -> {
if (somethingResult.succeeded()) {
response
.end(somethingResult.result());
} else {
routingContext.fail(500);
}
});
});
关于java - 如何阻止线程等待 vert.x 中的响应?,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/37206327/