は</p> <p>グアバ<a href="https://github.com/google/guava/wiki/ListenableFutureExplained" rel="nofollow noreferrer">Listenable Futures</a>を使用して

Question

が、私は以下のクラスがあると同等のRxJava構造にListenableFutureチェーンを変換しますパラメータにFoo。

私は一緒にチェーンにこれら2つの操作をしたい場合、私はこのような変圧器の機能を記述します。

AsyncFunction<Foo, Bar> fooToBar = new AsyncFunction<Foo, Bar>() { 

    @Override 
    ListenableFuture<Bar> apply(Foo resultantFoo) { 
     return barService.get(resultantFoo); 
    } 
}; 

し、このように変換を適用します。

public ListenableFuture<Bar> combinedFooToBar() { 
    ListenableFuture<Foo> futureFoo = fooService.get(); 
    return Futures.transformAsync(futureFoo, fooToBar); 
} 

が質問：何ですこれらのクラスとRxJavaに変換する場合の変換関数の同等の構文ですか？ FooServiceとBarServiceを適切なRxJava構造体に変換したいとします。 BarServiceのパラメータとしてFooServiceを呼び出した結果を使用して非同期タスクを連鎖させたいとします。

NB：RxJava構文について学び始めました。私が構文を研究し終えると、私は自分自身で質問に答えようとします。しかし、その間に誰かが答えたいなら、彼らは歓迎されます。

Answer 1

グアバコード次のようにRxJava2コードに変換：

FooService.java

public class FooService { 

    Observable<Foo> getFoo() { 
     return Observable.fromCallable(new Callable<Foo>() { 
      @Override 
      public Foo call() throws Exception { 
       return new Foo(); 
      } 
     }); 
    } 
} 

BarService.java

public class BarService { 

    Observable<Bar> getBar(final Foo foo) { 
     return Observable.fromCallable(new Callable<Bar>() { 
      @Override 
      public Bar call() throws Exception { 
       return new Bar(foo); 
      } 
     }); 
    } 
} 

FooBarService.java

したがって

public class FooBarService { 

    private final FooService fooService; 
    private final BarService barService; 

    public FooBarService(FooService fooService, BarService barService) { 
     this.fooService = fooService; 
     this.barService = barService; 
    } 

    Observable<Bar> getFooBar() { 
     return fooService.getFoo() 
       .concatMap(new Function<Foo, ObservableSource<? extends Bar>>() { 
        @Override 
        public ObservableSource<? extends Bar> apply(@NonNull Foo foo) throws Exception { 
         return barService.getBar(foo); 
        } 
       }); 
    } 
} 

、concatMapとflatMapはFutures.transformAsyncと同様であり、mapはFutures.transform（非非同期）と同様です。

ListenableFutureとObservableの間の変換のためのと呼ばれるこのGithubプロジェクトにも注意してください。