JAVA 中 API 链接的最佳设计模式

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

我想到了以下内容：

1. 对于返回对象的函数调用：从不返回 null。
2. 对于不(否则(返回任何内容的函数调用：返回this.
3. 接受 API 中的功能接口，以便用户可以自定义行为
4. 对于如上所述公开 API 的有状态对象，请提供生成器模式，以便用户最终不会在构造函数之间进行选择
5. 所描述的生成器的所有方法都必须无效，因此返回this

Answer 2

您可以创建一个ResponseStringBuilder类，该类需要Function<Response,String>才能从Response获取String。

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 中实现承诺。问题是，您正在尝试将两个不同的东西传递到"管道"中：请求，它是可变的并且(有时(会发生变化，以及结果，这是在调用过程中累积的。

我已经通过创建一个名为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个操作，你必须不断重新分配 promise，如下所示：

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();

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

(注意：最好使Request不可变，并在管道中传递一个新的、经过更改的，而不是改变它。另一方面，您也可以包装一个StringBuilder而不是一个String，并且你积累的数据也是可变的。现在它是可变和不可变的奇怪组合，但这与您的代码所做的事情相匹配。

Answer 4

感谢大家的投入，最后我找到了一个满足我需求的解决方案。我使用了一个单例来执行请求。对于每种类型的命令，都会有一组请求按一个特定顺序执行。每个命令都有要执行的特定请求顺序，我将其存储在具有请求唯一 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;
}