如何在PlayFrameworkJavaAPI中将可观察转换为承诺

我的默认承诺实现如下所示：

public F.Promise<Result> index() {
   return F.Promise.promise(() -> intensiveComputationSync())
       .map(result -> ok(String.valueOf(result)));
}

public F.Promise index（）{
返回F.Promise.Promise（（）->intensiveComputationSync（））
.map（结果->确定（字符串.valueOf（结果））；
}

但现在我有了rx api：

private Observable<Integer> intensiveComputationObservable() {
   return Observable.create(subscriber -> {
      try {
         subscriber.onNext(intensiveComputationSync());
      } catch (Exception e) {
         subscriber.onError(e);
      }
      subscriber.onCompleted();
   });
}

私有可观察强度计算可观察（）{
返回可观察。创建（订户->{
试一试{
subscriber.onNext（intensiveComputationSync（））；
}捕获（例外e）{
认股人。认股人（e）；
}
subscriber.onCompleted（）；
});
}

---

我如何在承诺中使用我的rx api？对正确的错误处理特别感兴趣。

似乎我找到了解决方案

用承诺包装可观察的功能：

   public static <T> F.Promise<T> observableToPromise(Observable<T> obs) {
      scala.concurrent.Promise<T> scalaPromise = scala.concurrent.Promise$.MODULE$.<T>apply();
      obs.subscribe(
          result -> scalaPromise.success(result),
          throwable -> scalaPromise.failure(throwable)
      );
      return F.Promise.wrap(scalaPromise.future());
   }

公共静态F.承诺可观察承诺（可观察obs）{
scala.concurrent.Promise scalaPromise=scala.concurrent.Promise$.MODULE$.apply（）；
订阅(
结果->缩放成功（结果），
可丢弃->缩放预览失败（可丢弃）
);
返回F.Promise.wrap（scalaPromise.future（））；
}

现在我的行动：

   public F.Promise<Result> index() {
      //convert observable to promise then map computation result to F.Promise<Result>
      F.Promise<Result> succeedPromise =
          observableToPromise(
              //computation on another thread
              intensiveComputationObservable().subscribeOn(Schedulers.newThread())
          ).map(result -> ok(String.valueOf(result)));

      //if exception while computation thrown, we returns another status
      return succeedPromise
          .recoverWith(throwable -> F.Promise.pure(internalServerError("error")));
   }

public F.Promise index（）{
//将可观测值转换为promise，然后将计算结果映射到F.promise
承诺成功的承诺=
可观察的承诺(
//另一个线程上的计算
intensiveComputationObservable（）.subscribeOn（Schedulers.newThread（））
).map（结果->确定（字符串.valueOf（结果））；
//如果计算时抛出异常，则返回另一个状态
回报成功的承诺
.recoverWith（throwable->F.Promise.pure（internalServerError（“error”））；
}

在游戏2.5中，有一种方法可以做到这一点：

public CompletableFuture<Result> callRPC() {
    Observable<Object> result =  <create observable>
    CompletableFuture<Object>  completableFuture = new CompletableFuture<>();

    result.subscribe((active) ->  completableFuture.complete(active),
            (err) -> completableFuture.completeExceptionally(err));

    return completableFuture.thenApply( i -> ok(Json.toJson(i)));

}

public CompletableFuture callRPC（）{
可观察结果=
CompletableFuture CompletableFuture=新的CompletableFuture（）；
结果。订阅（（活动）->completableFuture.complete（活动），
（err）->completableFuture.completeeexceptionaly（err））；
返回completableFuture.thenApply（i->ok（Json.toJson（i））；
}