如何重构Vert.x中的异步调用链以避免回调地狱？

嘿，我来帮你搞定Vert.x里这些有依赖的异步调用处理～ 针对你给出的foo1、foo2这类带Handler<AsyncResult<JsonObject>>的异步方法，我分几种常见场景给你整理解决方案：

如果你的业务逻辑是必须等前一个API返回结果，才能发起下一个调用（比如下一个调用需要用前一个返回的参数），那用Vert.x的Future链式调用是最清晰的方式，能避免回调嵌套的混乱。

首先我们可以把回调风格的方法包装成Future版本，方便后续链式操作：

// 把回调风格的foo1包装为Future版本
private Future<JsonObject> foo1Future(String uuid) {
    return Future.future(promise -> foo1(uuid, promise));
}

// 同理包装foo2
private Future<JsonObject> foo2Future(String uuid) {
    return Future.future(promise -> foo2(uuid, promise));
}

然后用compose方法串联调用，还能轻松保留所有结果：

foo1Future("initial-uuid")
    .compose(foo1Result -> {
        // 用foo1返回的uuid作为foo2的入参
        String targetUuid = foo1Result.getString("uuid");
        // 返回foo2的Future，继续链式
        return foo2Future(targetUuid)
            .map(foo2Result -> {
                // 把两个结果封装在一起，方便后续处理
                JsonObject combined = new JsonObject();
                combined.put("foo1_result", foo1Result);
                combined.put("foo2_result", foo2Result);
                return combined;
            });
    })
    .onSuccess(finalResult -> {
        // 这里拿到所有结果，做业务处理
        System.out.println("串行调用完成，合并结果：\n" + finalResult.encodePrettily());
    })
    .onFailure(error -> {
        // 任何一步调用失败都会走到这里，统一处理异常
        System.err.println("串行调用出错：" + error.getMessage());
    });

如果foo1和foo2之间没有依赖，可以同时发起调用，等全部完成后再统一处理结果，这样能大幅提升效率。用Future.all就能实现：

// 同时发起两个异步调用
Future<JsonObject> foo1Task = foo1Future("uuid-for-foo1");
Future<JsonObject> foo2Task = foo2Future("uuid-for-foo2");

// 等待所有任务完成
Future.all(foo1Task, foo2Task)
    .onSuccess(allResults -> {
        // 逐个取出结果
        JsonObject foo1Res = allResults.resultAt(0).result();
        JsonObject foo2Res = allResults.resultAt(1).result();
        
        System.out.println("foo1并行结果：\n" + foo1Res.encodePrettily());
        System.out.println("foo2并行结果：\n" + foo2Res.encodePrettily());
    })
    .onFailure(error -> {
        // 只要有一个任务失败，就会触发这里
        System.err.println("并行调用出错：" + error.getMessage());
    });

如果想忽略个别失败、只处理成功的结果，可以用Future.join：

Future.join(foo1Task, foo2Task)
    .onSuccess(allResults -> {
        for (AsyncResult<JsonObject> result : allResults) {
            if (result.succeeded()) {
                System.out.println("成功返回：\n" + result.result().encodePrettily());
            } else {
                System.err.println("单个任务失败：" + result.cause().getMessage());
            }
        }
    });

比如先调用foo1拿到基础参数，再并行调用foo2和foo3，最后汇总所有结果：

// 先定义foo3的Future版本（假设你有这个方法）
private Future<JsonObject> foo3Future(String uuid) {
    return Future.future(promise -> foo3(uuid, promise));
}

// 混合调用流程
foo1Future("initial-uuid")
    .compose(foo1Result -> {
        String sharedUuid = foo1Result.getString("uuid");
        // 并行发起foo2和foo3
        return Future.all(foo2Future(sharedUuid), foo3Future(sharedUuid))
            .map(parallelResults -> {
                // 汇总所有结果
                JsonObject finalCombined = new JsonObject();
                finalCombined.put("foo1", foo1Result);
                finalCombined.put("foo2", parallelResults.resultAt(0).result());
                finalCombined.put("foo3", parallelResults.resultAt(1).result());
                return finalCombined;
            });
    })
    .onSuccess(totalResult -> {
        System.out.println("混合调用完成，全部结果：\n" + totalResult.encodePrettily());
    })
    .onFailure(error -> {
        System.err.println("混合调用出错：" + error.getMessage());
    });

如果不想用Future链式，也可以直接用回调嵌套，但逻辑复杂时容易陷入“回调地狱”，只适合简单场景：

foo1("initial-uuid", ar1 -> {
    if (ar1.succeeded()) {
        JsonObject foo1Res = ar1.result();
        String foo2Uuid = foo1Res.getString("uuid");
        
        foo2(foo2Uuid, ar2 -> {
            if (ar2.succeeded()) {
                JsonObject foo2Res = ar2.result();
                // 处理两个结果
                System.out.println("foo1结果：\n" + foo1Res.encodePrettily());
                System.out.println("foo2结果：\n" + foo2Res.encodePrettily());
            } else {
                System.err.println("foo2调用失败：" + ar2.cause().getMessage());
            }
        });
    } else {
        System.err.println("foo1调用失败：" + ar1.cause().getMessage());
    }
});

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