Question

假设我有以下课程：

public class FooService {
    ListenableFuture<Foo> getFoo() {
        //code to create callable, then
        return listeningExecutorService.submit(fooCallable);
    }
}

以及以下课程：

public class BarService {
    ListenableFuture<Bar> getBar(Foo foo) {
        //code to create callable, then
        return listeningExecutorService.submit(barCallable);
    }
}

请注意，getBar在参数中需要Foo。

如果我想将这两个操作链接在一起，我会写一个像这样的变换器函数：

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结构。假设我们希望使用调用FooService的结果作为BarService的参数来链接异步任务。

注意：我刚开始学习RxJava语法。当我完成语法学习后，我将尝试自己回答这个问题。但是，与此同时，如果有人想回答，欢迎他们。

Answer 1

Guava代码转换为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相似（非同步）。

另请注意，这个Github项目名为Future Converter，用于ListenableFuture和Observable之间的转换。

将ListenableFuture链转换为等效的RxJava结构

1 个答案: