我有一种情况，我调用外部 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/