使用 Java 实现 Play 框架中的链式 Promise

Question

我有一个控制器操作，我需要调用第 3 方网络服务。

我的问题是我没有调用一项网络服务。我需要链接 4 到 5 个 Web 服务。我调用的每个 Web 服务都返回一个我需要处理的 JSON 对象，并且基于某些逻辑，我决定调用另一个 Web 服务（来自 4 个 Web 服务）或向调用者返回响应。这是我想要做的：

 public static Promise<Result> accounts(){
    return WS.url("url1").get().map(response1 -> {
        JsonNode mynode = response1.asJson();

        if (mynode.get("status").asInt()==200){
            Promise<JsonNode> jsonPromise = WS.url("url2").get().map(response2->{
                    return response2.asJson();
            });
        }

        return ok(mynode);
        }); 
}

现在，从文档来看，我认为我需要的是在每个 Web 服务调用都是一个 Promise 的地方链接 Promise。但我不知道该怎么做？

谢谢

Answer 1

他们称它为 Reactive Composition，它就是这样完成的 ->

public static Promise<Result> reactiveCombo() {
    Promise<WSResponse> promise1 = WS.url("url1").get();
    Promise<WSResponse> promise2 = WS.url("url2").get();
    Promise<WSResponse> promise3 = WS.url("url3").get();

    return promise1.flatMap(response1 -> {
        final JsonNode json1 = response1.asJson();
        if (!json1.has("someField")) {
            return Promise.promise(() -> badRequest());
        }
        return promise2.flatMap(response2 -> {
            final JsonNode json2 = response2.asJson();
            if (json1.get("someField").asText().equals(json2.get("someField").asText())) {
                return Promise.promise(() -> badRequest());
            }
            return promise3.map(response3 -> {
                final JsonNode json3 = response3.asJson();
                if (json3.get("boolField").asBoolean()) {
                    return badRequest();
                }
                return ok();
            });
        });
    });
}

对于大量调用，您可以使用Promise.sequence() 并获得“创意”：

private static Promise<JsonNode> getPromise(String url, Predicate<JsonNode> predicate) {
    return WS.url(url).get().map(response -> {
        JsonNode json = response.asJson();           
        if (predicate.negate().test(json)) {
            throw new Exception("BUMMER!");
        }
        return json;
    });
}

public static Promise<Result> reactiveCombo(List<String> urls) {
    List<Promise<JsonNode>> promises = new ArrayList<Promise<JsonNode>>(urls.size());
    Predicate<String> predURL = p -> p.contains("goodApi");
    Predicate<JsonNode> pred1 = p -> p.has("boolField") && p.get("boolField").asBoolean();
    Predicate<JsonNode> pred2 = p -> p.has("someField");

    urls.forEach(url -> {
        Promise<JsonNode> promise = predURL.test(url) ? getPromise(url, pred1) : getPromise(url, pred2);           
        promises.add(promise);
    });

    return Promise.sequence(promises).map(results -> ok()).recover(t -> badRequest());
}

其他细节+纪录片：

Go Reactive with Java 8 & Play Framework（旧但仍有教育意义）

JavaWS

Answer 2

对于任意数量的 Promise，您可以使用递归来扁平化此结构。 首先创建一个类：

public static class ChainedWebService {
    public final Optional<ChainedWebService> next;

    public final WSRequestHolder wsResponsePromise;
    private final F.Predicate<JsonNode> predicate;

    public ChainedWebService(String url, Optional<ChainedWebService> next, F.Predicate<JsonNode> predicate) {
        this.next = next;
        this.wsResponsePromise = WS.url(url);
        this.predicate = predicate;
    }

    public F.Promise<Result> processChain() {
        return wsResponsePromise.get().flatMap(new F.Function<WSResponse, F.Promise<Result>>() {
            @Override
            public F.Promise<Result> apply(WSResponse wsResponse) throws Throwable {
                if (!predicate.test(wsResponse.asJson())) {
                    return F.Promise.pure(badRequest());
                }

                if (!next.isPresent()) {
                    return F.Promise.pure(ok());
                }

                return next.get().processChain();
            }
        });
    }
}

然后使用它：

public static F.Promise<Result> reactiveCombo() {
    ChainedWebService chainedWebService3 = new ChainedWebService(
            "url3",
            Optional.<ChainedWebService>empty(),
            jsonNode -> jsonNode.get("boolField").asBoolean()
    );

    ChainedWebService chainedWebService2 = new ChainedWebService(
            "url2",
            Optional.of(chainedWebService3),
            jsonNode -> jsonNode.get("someField").asText().equals(jsonNode.get("someField").asText()));

    ChainedWebService chainedWebService1 = new ChainedWebService(
            "url1",
            Optional.of(chainedWebService2),
            jsonNode -> jsonNode.has("someField")
    );

    return chainedWebService1.processChain();
}

您可以实现一些基本的构建器，使构建过程更加合理。

希望对你有帮助！