Vert.x中如何从EventBus异步回调中获取结果并返回？

嗨，这个问题我太熟了！你现在遇到的是异步编程里最经典的「同步思维套异步代码」的问题——你的someMethod是同步方法，但EventBus的send是异步非阻塞操作，回调里的代码要等EventBus收到响应后才会执行，而此时someMethod早已经跑到return语句了，自然拿不到回调里的结果。

要解决这个问题，你得切换到异步思维，下面给你几种Vert.x生态里常用的方案：

方案1：用Vert.x原生的Future和Promise（推荐） #

把方法的返回类型改成Future<Result<Integer>>，用Promise来封装异步结果，这是Vert.x官方推荐的异步处理方式，和整个框架的生态适配性最好。

修改后的代码大概是这样：

class Result<T> {
    public T value;
    public String message;
    // 假设你有这些静态方法：
    public static <T> Result<T> succeed(T value) { /* 实现逻辑 */ }
    public static <T> Result<T> fail(String message) { /* 实现逻辑 */ }
    public boolean isSuccessful() { /* 实现逻辑 */ }
}

private Future<Result<Integer>> someMethod() {
    Promise<Result<Integer>> promise = Promise.promise();
    try {
        var json = new JsonObject();
        vertx.eventBus().<JsonObject>send(Service.EVENT_BUS_ADDRESS, json, ar -> {
            if (ar.succeeded()) {
                var resultBody = ar.result().body();
                // 根据业务逻辑将JsonObject转为Result<List>
                Result<List> remoteResult = new Result<>(resultBody);
                if (remoteResult.isSuccessful()) {
                    // 这里根据你的业务把List转成Integer结果
                    promise.complete(Result.succeed(/* 你的Integer结果 */));
                } else {
                    promise.complete(Result.fail(remoteResult.message));
                }
            } else {
                promise.complete(Result.fail("Remote server error"));
            }
        });
    } catch (Exception e) {
        e.printStackTrace();
        promise.complete(Result.fail(e.getMessage()));
    }
    return promise.future();
}

调用这个方法时，通过onComplete处理结果：

someMethod().onComplete(resultAr -> {
    if (resultAr.succeeded()) {
        Result<Integer> finalResult = resultAr.result();
        // 处理最终业务结果
    } else {
        // 处理失败场景
    }
});

方案2：给方法添加回调参数 #

如果不想用Future，也可以直接让调用方传入一个Handler来接收结果，这也是异步编程里很常见的写法：

private void someMethod(Handler<AsyncResult<Result<Integer>>> resultHandler) {
    try {
        var json = new JsonObject();
        vertx.eventBus().<JsonObject>send(Service.EVENT_BUS_ADDRESS, json, ar -> {
            if (ar.succeeded()) {
                var resultBody = ar.result().body();
                Result<List> remoteResult = new Result<>(resultBody);
                if (remoteResult.isSuccessful()) {
                    resultHandler.handle(Future.succeededFuture(Result.succeed(/* Integer结果 */)));
                } else {
                    resultHandler.handle(Future.succeededFuture(Result.fail(remoteResult.message)));
                }
            } else {
                resultHandler.handle(Future.succeededFuture(Result.fail("Remote server error")));
            }
        });
    } catch (Exception e) {
        e.printStackTrace();
        resultHandler.handle(Future.succeededFuture(Result.fail(e.getMessage())));
    }
}

调用时直接传入处理逻辑：

someMethod(resultAr -> {
    Result<Integer> finalResult = resultAr.result();
    // 处理结果
});

方案3：用Vert.x协程（Vert.x 4+支持） #

如果你用的是Vert.x 4及以上版本，还可以用Java虚拟线程（Vert.x 4.3+支持）来写，让代码看起来像同步的，但本质还是异步非阻塞的：

private Result<Integer> someMethod() throws Exception {
    try {
        var json = new JsonObject();
        // 使用await等待EventBus的响应
        var response = vertx.eventBus().<JsonObject>request(Service.EVENT_BUS_ADDRESS, json).await();
        var resultBody = response.body();
        Result<List> remoteResult = new Result<>(resultBody);
        if (remoteResult.isSuccessful()) {
            return Result.succeed(/* Integer结果 */);
        } else {
            return Result.fail(remoteResult.message);
        }
    } catch (Exception e) {
        e.printStackTrace();
        return Result.fail(e.getMessage());
    }
}

注意：这种方法需要你在Verticle里启用虚拟线程，或者配合协程运行时使用。

最后再敲个重点：同步方法里不可能直接返回异步操作的结果，因为异步操作的执行时机在方法返回之后，必须用异步的方式（Future、回调、协程）来处理结果，这是异步编程的核心思维哦！

内容的提问来源于stack exchange，提问作者Ukonn Ra