Question

我想用Java调用一系列API调用。要求是某些API的响应将用于后续API调用的请求中。我可以使用某些循环来实现这一点。但我想以这样的方式使用设计模式，即实现是通用的。有什么帮助吗？

责任链并不符合我的需要，因为我一开始并不知道我的请求背景是什么。

String out = null;
Response res = execute(req);
out += res.getOut();
req.setXYZ(res.getXYZ);
Response res = execute(req);
out += res.getOut();
req.setABC(res.getABC);
Response res = execute(req);
out += res.getOut();

System.out.println("Final response::"+out);

Answer 1

以下是我的想法：

对于返回对象的函数调用：永远不返回null。
对于没有（否则）返回任何内容的函数调用：return this。
接受API中的功能接口，以便用户可以自定义行为
对于如上所述公开API的有状态对象，提供Builder模式，以便用户不必在构造函数之间进行选择
所描述的Builder的所有方法都必须无效，因此返回this

Answer 2

您可以创建一个mode="#all except (mode5, mode6)"课程，该ResponseStringBuilder课程需要Function<Response,String>从String获取Response。

public ResponseStringBuilder {
    private Request request;
    public StringBuilder resultBuilder = new StringBuilder();
    public ResponseBuilder(Request req) {
        this.request = req;
    }
    public ResponseStringBuilder fromExtractor(Function<Request, Response> getResponse, Function<Response,String> extract) {
        Response response = getResponse.apply(request);
        resultBuilder.append(extract.apply(response));
        return this;
    }
    public String getResult() {
         return resultBuilder.toString();
    }
}

那会打电话

ResponseStringBuilder builder = new ResponseStringBuilder(req);
@SuppressWarnings("unchecked")
Function<Response,String> extractors = new Function[] {
    Response::getABC, Response::getXYZ 
};
for (Function<Response,String> ext : extractors) {
    builder = builder.fromExtractor(this::execute, ext);
}
System.out.println("final response: " + builder.getResult());

不确定数组声明是否实际编译，但它应该只需稍加修改就可以了，你就得到了要点。

Answer 3

您可以使用CompletableFuture在Java中实现promise。问题是，你试图在管道上传递两种不同的东西：＆＃39;请求，它是可变的（有时）更改，以及在调用过程中累积的结果。

我通过创建一个名为Pipe的类来创建一个请求，以及到目前为止结果的累加器。它有两个getter，并且它有一些方便的方法来返回带有累积结果的新对象，甚至可以改变请求并在一次调用中累积。这使得API的代码更加清晰。

字段，构造函数和getter之后的with*方法是处理累积和变异的方法。 chain方法将所有内容放在一起：

import java.util.concurrent.CompletableFuture;

public class Pipe {
    private Request req;
    private String out;

    public Pipe(Request req, String out) {
        this.req = req;
        this.out = out;
    }

    public Request getReq() {
        return req;
    }

    public String getOut() {
        return out;
    }

    public Pipe with(String data) {
        return new Pipe(req, out + data);
    }

    public Pipe withABC(String abc, String data) {
        req.setABC(abc);
        return new Pipe(req, out + data);
    }

    public Pipe withXYZ(String xyz, String data) {
        req.setXYZ(xyz);
        return new Pipe(req, out + data);
    }

    public static void chain(Request req) throws Exception {
        var promise = CompletableFuture.supplyAsync(() -> new Pipe(req, ""))
        .thenApply(pipe -> {
            Response res = execute(pipe.getReq());
            return pipe.withABC(res.getABC(), res.getOut());
        })
        .thenApply(pipe -> {
            Response res = execute(pipe.getReq());
            return pipe.withXYZ(res.getXYZ(), res.getOut());
        })
        .thenApply(pipe -> {
            Response res = execute(pipe.getReq());
            return pipe.with(res.getOut());
        });

        var result = promise.get().getOut();

        System.out.println(result);
    }

    public static Response execute(Request req) {
        return req.getResponse();
    }
}

因为它以异步方式运行，所以它可以抛出InterruptedException，如果其他东西中断，它也会抛出ExecutionException。我不知道你想怎么处理，所以我只是宣布chain要扔掉。

如果您想在循环中应用 n 操作，您必须继续重新分配承诺，如下所示：

var promise = CompletableFuture.supplyAsync(() -> new Pipe(req, ""));

for (...) {
    promise = promise.thenApply(pipe -> {
        Response res = execute(pipe.getReq());
        return pipe.with(res.getOut());
    });
}

var result = promise.get().getOut();

我在这里使用了带有var的Java 10类型推断，但promise和result的类型将是CompletableFuture<Pipe>和String，分别

（注意：最好让Request成为不可变的，并将一个新的，改变的一个传递给管道而不是改变它。另一方面，你也可以包裹一个StringBuilder而不是一个String，并且你正在积累的数据也是可变的。现在它是可变和不可变的奇怪组合，但它与你的代码所做的相符。）

Answer 4

感谢大家的投入，最后我找到了一个满足我需求的解决方案。我使用一个Singleton来执行请求。对于每种类型的命令，将以一组特定顺序执行一组请求。每个命令都具有要执行的特定请求顺序，我将其与请求的唯一ID一起存储在数组中。然后将数组保留在命令名称对应的映射中。

在循环中，我运行数组并执行，每次迭代后，我都将响应设置回请求对象，并最终准备输出响应。

    private static Map<RequestAction,String[]> actionMap = new HashMap<RequestAction, String[]>();

    static{
    actionMap.put(RequestAction.COMMAND1,new String[]{WebServiceConstants.ONE,WebServiceConstants.TWO,WebServiceConstants.FOUR,WebServiceConstants.THREE});
    actionMap.put(RequestAction.THREE,new String[]{WebServiceConstants.FIVE,WebServiceConstants.ONE,WebServiceConstants.TWO});}


    public Map<String,Object> execute(ServiceParam param) {

    String[] requestChain = getRequestChain(param);

    Map<String,Object> responseMap = new HashMap<String, Object>();


    for(String reqId : requestChain) {

        prepareForProcessing(param, tempMap,responseMap);

        param.getRequest().setReqId(reqId);

        //processing the request
        tempMap = Service.INSTANCE.process(param);

        //prepare responseMap using tempMap         

        param.setResponse(response);

    }

    return responseMap;
}

JAVA中API链的最佳设计模式

4 个答案: