Java 如何转换列表<；T>；流动<；T>；使用反应器3.x

我有一个Asyn call thrift接口：

public CompletableFuture-getfavorities（长用户ID）{
CompletableFuture=新的CompletableFuture（）；
OctoThriftCallback=新的OctoThriftCallback（thriftExecutor）；
callback.addObserver（新的OctorObserver（）{
@凌驾
成功时的公共无效（对象o）{
未来。完成（（列表）o）；
}
@凌驾
失败时的公共无效（可丢弃）{
未来。完全例外（可丢弃）；
}
});
试一试{
recommendAsyncService.getFavorites（用户标识，回调）；
}捕获（特克斯）{
log.error（“OctoCall RecommendAsyncService.getFavorites”，e）；
}
回归未来；
}

现在它返回了一个完整的未来。然后我调用它来做一些处理器，使用通量

public Flux getrecomment（长用户ID）抛出InterruptedException、ExecutionException、TimeoutException{
//我不喜欢
List recommendList=wrapper.getRecommend（userId）.get（2，TimeUnit.SECONDS）；
系统输出打印LN（推荐列表）；
返回流量。可从列表中选择（推荐列表）
.flatMap（id->Mono.defer（（）->Mono.just（Product.builder）（）
.userId（userId）
.productId（id）
.productType（（int）（Math.random（）*100））
.build（）））
.采取（5）
.publishOn（mdpScheduler）；
}

但是，我想从

getFavorites

方法中获得流量，我可以在

getRecommend

方法中使用它。

---

或者，您可以推荐一个

流量API

，我可以将

列表推荐列表

转换为

流量推荐流量

，将

可完成的未来

转换为

流量

，您可以使用：

或者简单地使用一次多次排放：

Flux<Long> flux = Flux.create(sink -> {
  Callback<List<Long>> callback = new Callback<List<Long>>() {
    @Override
    public void onResult(List<Long> list) {
      list.forEach(sink::next);
    }

    @Override
    public void onError(Exception e) {
      sink.error(e);
    }
  };
  client.call("query", callback);
});

flux.subscribe(System.out::println);

Flux-Flux=Flux.create（sink->{
Callback Callback=new Callback（）{
@凌驾
公共无效onResult（列表）{
list.forEach（sink:：next）；
}
@凌驾
公共无效申报人（例外e）{
错误（e）；
}
};
client.call（“查询”，回调）；
});
订阅（System.out:：println）；

Int直接使用Mono#create with Mono#flatMapMany的部分。我无法实现回调。我是否使用了错误的工具？或者只提供一个伪代码？@dyy.alex，

Callback

是您必须自己创建的类的接口。或者使用客户端库提供的库（

客户端

变量后面的库）。

Flux<Long> flux = Mono.<List<Long>>create(sink -> {
  Callback<List<Long>> callback = new Callback<List<Long>>() {
    @Override
    public void onResult(List<Long> list) {
      sink.success(list);
    }

    @Override
    public void onError(Exception e) {
      sink.error(e);
    }
  };
  client.call("query", callback);
}).flatMapMany(Flux::fromIterable);

flux.subscribe(System.out::println);

Flux<Long> flux = Flux.create(sink -> {
  Callback<List<Long>> callback = new Callback<List<Long>>() {
    @Override
    public void onResult(List<Long> list) {
      list.forEach(sink::next);
    }

    @Override
    public void onError(Exception e) {
      sink.error(e);
    }
  };
  client.call("query", callback);
});

flux.subscribe(System.out::println);