如何优雅的同步等待vertx异步回调AsyncResult

罗山仔

已于 2022-12-07 22:28:56 修改

阅读量1.3k

点赞数 1

文章标签： java

于 2022-12-07 14:53:15 首次发布

本文链接：https://blog.csdn.net/luomin369433047/article/details/128215793

版权

如何优雅的同步等待vertx异步回调

- - - 情景

在vertx中，所有的api，均为异步回调。在实际项目开发中，这些异步回调，将导致出现回调地狱的问题。往往我们需要已同步的方式，调用这些异步方法。

为了可以将异步任务编排起来，vertx为我们提供几套参考的方案：

情景

在一个spring技术栈构建的应用A中，需要通过vertx service proxy调用由vertx构建的下游服务。应用A中，我们是需要获取下游服务的异步结果。

通常我们需要一个Future来做这件事情。但vertx的提供Future的不具备阻塞获取结果的能力（The Golden Rule - Don’t Block the Event Loop，这也能理解）。

这里提供一个小demo，减少样板代码。

下游vertx服务

@ProxyGen
public interface HelloService {
    void sayHello(String name, Handler<AsyncResult<String>> resultHandler);
}

@ProxyGen
public interface NameService {
    void getName(Handler<AsyncResult<String>> resultHandler);
}

应用A调用方

@RestController
public class HelloController {

    @Autowired
    private HelloService helloService;

    @Autowired
    private NameService nameService;

    @GetMapping("/index")
    public String index() throws ExecutionException, InterruptedException {
        String name = AwaitUtil.awaitResult(resultHandler -> this.nameService.getName(resultHandler));
        String msg = AwaitUtil.awaitResult(resultHandler -> this.helloService.sayHello(name, resultHandler));
        return msg;
    }

}

AwaitUtil

public class AwaitUtil {

    public static <T> T awaitResult(Consumer<Handler<AsyncResult<T>>> runnable) throws ExecutionException, InterruptedException {
        // TODO: 2022/12/5 如果是在vertx的io线程调用future.get()会导致io线程陷入死阻塞
        checkVertxEventLoop();
        CompletableFuture<T> future = toCompletableFuture(runnable);
        return future.get();
    }

    public static <T> CompletableFuture<T> toCompletableFuture(Consumer<Handler<AsyncResult<T>>> runnable) {
        checkVertxEventLoop();
        CompletableFuture<T> future = new CompletableFuture<>();
        Handler<AsyncResult<T>> resultHandler = newHandler(future);
        runnable.accept(resultHandler);
        return future;
    }

    private static <T> Handler<AsyncResult<T>> newHandler(CompletableFuture<T> future) {
        return event -> {
            if (event.succeeded()) {
                future.complete(event.result());
            } else future.completeExceptionally(event.cause());
        };
    }

    private static void checkVertxEventLoop() {
        if (isInVertxEventLoop()) throw new RuntimeException("not support blocking call in vertx eventLoop");
    }

    private static boolean isInVertxEventLoop() {
        return Thread.currentThread() instanceof VertxThread && ((VertxThread) Thread.currentThread()).isWorker();
    }
}