RxJava的Observable.create与Observable.just（1）.flatMap

Question

I've been doing a bit of RxJava and i often find myself in the case where I need to transform some existing code result to an observable.

For instance let's take the following:

ListenableFuture<T> result = request.executeAsync();
return result;

So the easiest way to transform this to an observable is to do

ListenableFuture<T> result = request.executeAsync();
return Observable.from(result);

The thing is that executeAsync actually executes the request when it's called. What I want is to delay that call until the observable is subscribed to.

I thought of two ways of doing this

return Observable.create { aSubscriber ->
    if (!aSubscriber.unsubscribed) {
        aSubscriber.onNext(request.executeAsync())
    }
    if (!aSubscriber.unsubscribed) {
        aSubscriber.onCompleted()
    }
}

and

return Observable
    .just(1)
    .flatMap((_) -> Observable.from(request.executeAsync()));

It looks to me like it's simpler to use the flatMap option as I don't have to bother with the subscriber logic.

Is there any pitfall in using flatMap over create ? Is there a preferred Rx way to ease integration ?

Thanks

Answer 1

You can use defer instead :

Observable.defer(() -> request.executeAsync())
          .concatMap(Observable::from)
          .subscribe();

Answer 2

RxJavaGuava is a small library which converts ListenableFuture to Observable for you, so you'd better use this than a "home-made" solution. It allows you to write

ListenableFutureObservable.from(request.executeAsync(), Schedulers.computation())

Depending on what the request does, you'll have to pick the right scheduler.