Java 无法将completable future的结果获取到响应对象中

我使用java.util.concurrent与Java8的CompletableFuture接口调用了四个API。我希望执行多个rest调用，合并结果并返回JSON

我尝试过未来，它对我有用。然后我也想尝试一下完整的未来

公共映射getAllValuesInParallel2（RequestObj RequestObj）{ Map response=newhashmap（）； ExecutorService executor=Executors.newFixedThreadPool（6）； CompletableFuture.SupplySync（（）->{ 列表键=新的ArrayList（）； 添加（“马尼”）； 返回aClient.transform（key，requestObj）； }，执行人）。然后申请（s->{ PutinoResponse（响应，s）； 返回true； }); CompletableFuture.SupplySync（（）->{ 列表键=新的ArrayList（）； 密钥。添加（“gani”）； 返回bClient.transform（键、请求对象）； }，执行人）。然后申请（s->{ PutinoResponse（响应，s）； 返回true； }); CompletableFuture.SupplySync（（）->{ 列表键=新的ArrayList（）； 添加（“priya”）； 返回cClient.transform（键、请求对象）； }，执行人）。然后申请（s->{ PutinoResponse（响应，s）； 返回true； }); CompletableFuture.SupplySync（（）->{ 列表键=新的ArrayList（）； 添加（“ravi”）； 返回dClient.transform（key，requestObj）； }，执行人）。然后申请（s->{ PutinoResponse（响应，s）； 返回true； }); 返回响应； } 私有无效PutinoResponse（映射响应，列表s）{ 如果（s.size（）>0）{ 用于（地图：s）{ if（maps！=null&&maps.containsKey（“abcd”））{ 字符串abcd=maps.get（“abcd”）.toString（）； 如果（！response.containsKey（abcd）） response.put（maps.get（“abcd”）.toString（），maps）； 否则{ 对于（Map.Entry:maps.entrySet（））{ response.get（abcd）.put（entry.getKey（），entry.getValue（））； } } } } } } 我正在调用四个API。我得到一个Hashmap列表作为每个API的响应。现在，需要将每个API的结果合并到一个响应中，即映射的映射。所以，我想，当我从一个API得到响应时，我把结果放到hashmap中

但我得到的是一个空洞的回答。这里completable future调用API，但服务器不等待调用响应并返回。 如何让服务器等待？ 请建议一种方法，以便我可以在将来完整地执行此用例。 另外，建议一些更干净的方法

从API获得的响应：

{ 
   {
    "abcd": 1,
    "cde": 2
   },
   { 
    "abcd": 2,
     "cde": 3
   }
}

{
   "1" : {
    "abcd": 1,
    "cde": 2
   },
   "2":{ 
    "abcd": 2,
     "cde": 3
   }

}

将上述响应解析为：

{ 
   {
    "abcd": 1,
    "cde": 2
   },
   { 
    "abcd": 2,
     "cde": 3
   }
}

{
   "1" : {
    "abcd": 1,
    "cde": 2
   },
   "2":{ 
    "abcd": 2,
     "cde": 3
   }

}

---

我认为您的问题在于，

CompletableFuture.supplyAsync（）

没有被阻止，因此您的代码会立即向前移动，而不是等待异步操作应用

代码是以异步方式执行的，在本例中，这意味着您可以告诉

CompletableFuture.supplyAsync（）

中要执行的操作，然后继续执行。只有当

supplyAsync

中的代码完成执行时，才会调用

thenApply（）

部分，这很可能发生在您已经返回

响应之后

如果要在返回
响应之前等待所有
CompletableFuture
完成执行，则应使用
CompletableFuture.join（）
方法

首先尝试重构代码，去掉
部分，然后应用（）
部分，这样~CompletableFutures`就会得到部分响应

然后将所有
CompletableFutures
分配给一些变量（
myFirstFuture
，
mySecondFuture
等）

之后，使用
流
对所有
CompletableFutures
应用
join（）
方法，并对每个结果应用
putInResponse
方法

例如：

public Map<String, Map<String, Object>> getAllValuesInParallel2(RequestObj requestObj) {

    Map<String, Map<String, Object>> response = new HashMap<>();
    ExecutorService executor = Executors.newFixedThreadPool(6);
    CompletableFuture<List<Map<String, Object>>> myFuture1 = CompletableFuture.supplyAsync(() -> {
        List<Template> keys = new ArrayList<>();
        keys.add("mani");
        return aClient.transform(keys, requestObj);
    }, executor);

    CompletableFuture<List<Map<String, Object>>> myFuture2 = CompletableFuture.supplyAsync(() -> {
        List<Template> keys = new ArrayList<>();
        keys.add("gani");
        return bClient.transform(keys, requestObj);
    }, executor);

    CompletableFuture<List<Map<String, Object>>> myFuture3 = CompletableFuture.supplyAsync(() -> {
        List<Template> keys = new ArrayList<>();
        keys.add("priya");
        return cClient.transform(keys, requestObj);
    }, executor);

    CompletableFuture<List<Map<String, Object>>> myFuture4 = CompletableFuture.supplyAsync(() -> {
        List<Template> keys = new ArrayList<>();
        keys.add("ravi");
        return dClient.transform(keys, requestObj);
    }, executor);

    Stream.of(myFuture1, myFuture2, myFuture3, myFuture4)
        .map(CompletableFuture::join)
        .filter(Objects::nonNull)
        .forEachOrdered(s -> putIntoResponse(response, s));


    return response;
}

公共映射getAllValuesInParallel2（RequestObj RequestObj）{
Map response=newhashmap（）；
ExecutorService executor=Executors.newFixedThreadPool（6）；
CompletableFuture myFuture1=CompletableFuture.supplyAsync（（）->{
列表键=新的ArrayList（）；
添加（“马尼”）；
返回aClient.transform（key，requestObj）；
}，遗嘱执行人）；
CompletableFuture myFuture2=CompletableFuture.supplyAsync（（）->{
列表键=新的ArrayList（）；
密钥。添加（“gani”）；
返回bClient.transform（键、请求对象）；
}，遗嘱执行人）；
CompletableFuture myFuture3=CompletableFuture.supplyAsync（（）->{
列表键=新的ArrayList（）；
添加（“priya”）；
返回cClient.transform（键、请求对象）；
}，遗嘱执行人）；
CompletableFuture myFuture4=CompletableFuture.supplyAsync（（）->{
列表键=新的ArrayList（）；
添加（“ravi”）；
返回dClient.transform（key，requestObj）；
}，遗嘱执行人）；
（myFuture1、myFuture2、myFuture3、myFuture4）
.map（CompletableFuture:：join）
.filter（对象：：非空）
.forEachOrdered（s->PutinoResponse（response，s））；
返回响应；
}
HashMap对于多线程使用是不安全的。使用
response=newConcurrentHashMap（）取而代之。