Java中带有cachedHostConnectionPool的Source.queue

我试图在java中将source.queue与cachedHostConnectionPool一起使用，但无法获得正确的输出。下面是我的尝试。我总是得到成功的回应，我理解为什么，但不确定什么是正确的方法

我之所以得到成功响应，是因为我将Try定义为HttpResponse.create（），它总是给我成功响应，但我的疑问是，为什么在我执行queue.offer（Pair.create（httprequest，promise））时它没有被覆盖。 有人能帮我理解我做错了什么吗

// Method to return queue 
  public SourceQueueWithComplete<Object> httpGetRequestWithPool
          (Materializer materializer) 
{
    final Http http = Http.get(system);
     final Flow<Pair<HttpRequest, Object>, Pair<Try<HttpResponse>, Object>, HostConnectionPool> flow;
      flow = http.cachedHostConnectionPool(ConnectHttp.toHost("host:port"));
    final SourceQueueWithComplete<Object> queue= Source.queue(3,OverflowStrategy.dropNew())
                 .map(d -> Pair.create(HttpRequest.create("contextpath"),d))
                 .via(flow)
                 .toMat(Sink.foreach(p -> p.first()), Keep.left())
                 .run(materializer);
    return queue;
  }

// Here i am trying to use.

  SourceQueueWithComplete<Object> queue = util.httpGetRequestWithPool(materializer);
        Source<Object, NotUsed> source = Source.from(ListOfObject);
        source.mapAsyncUnordered(3,x-> {
            String url = util.getServiceUrl("servicename").append(x.getId).toString();
            HttpRequest httpRequest = HttpRequest.create(url);
            Try<HttpResponse> promise = Try.apply(()->HttpResponse.create());
            queue.offer(Pair.create(httpRequest,promise))
                    .thenCompose(result -> {
                        if(result instanceof QueueOfferResult.Enqueued$){
                         return CompletableFuture.completedFuture(promise)
                                    .thenApply(res ->{
                                       if(res.get().status().intValue()==200){
                                           System.out.println("success");
                                       }
                                       return res;
                                    });
                        }
                        else{
                            return CompletableFuture.completedFuture(HttpResponse.create().withStatus(StatusCodes.SERVICE_UNAVAILABLE));

                        }
                    });
            return null;
        }).run(materializer);
```

//返回队列的方法
public SourceQueueWithComplete httpGetRequestWithPool
（物化器物化器）
{
最终Http=Http.get（系统）；
最终流量；
flow=http.cachedHostConnectionPool（ConnectHttp.toHost（“主机：端口”））；
final SourceQueueWithComplete queue=Source.queue（3，OverflowStrategy.dropNew（））
.map（d->Pair.create（HttpRequest.create（“contextpath”），d））
.通过（流量）
.toMat（Sink.foreach（p->p.first（）），Keep.left（））
.run（物化器）；
返回队列；
}
//在这里，我试图使用。
SourceQueueWithComplete queue=util.httpGetRequestWithPool（物化器）；
Source Source=Source.from（ListoObject）；
source.mapAsyncUnordered（3，x->{
字符串url=util.getServiceUrl（“servicename”）.append（x.getId）.toString（）；
HttpRequest HttpRequest=HttpRequest.create（url）；
Try promise=Try.apply（（）->HttpResponse.create（））；
queue.offer（Pair.create（httpRequest，promise））
.然后撰写（结果->{
if（QueueOfferResult.Enqueued$的结果实例）{
返回CompletableFuture.completedFuture（承诺）
。然后应用（res->{
if（res.get（）.status（）.intValue（）==200）{
System.out.println（“成功”）；
}
返回res；
});
}
否则{
返回CompletableFuture.completedFuture（HttpResponse.create（）.withStatus（StatusCodes.SERVICE_UNAVAILABLE））；
}
});
返回null；
}).run（物化器）；
```