Question

我有4个可观察的，我想把它叫做序列

Observable1 //return boolean
-> Observable2 // if(Observable1 result == true) { call Observable3 } else { call observable4 }
-> Observable3 // call Observable4
-> Observable4
-> subscribe();

我试过了，但当Observable1的结果为false时，onCompleted名为

Observable
    .fromCallable(new Callable<Boolean>() {
        @Override
        public Boolean call() throws Exception {
            return false;
        }
    })
    .flatMap(new Func1<Boolean, Observable<String>>() {
        @Override
        public Observable<String> call(Boolean aBoolean) {
            if(aBoolean) {
                return Observable.just("to Observable2");
            }
            return null; // to Observable 3
        }
    })
    .flatMap(new Func1<String, Observable<Integer>>() {
        @Override
        public Observable<Integer> call(String s) {
            return Observable.just(1);  //to Observable3
        }
    })
    .flatMap(new Func1<Integer, Observable<Boolean>>() {
        @Override
        public Observable<Boolean> call(Integer integer) {
            return Observable.just(true); //success
        }
    })
    .subscribe(new Subscriber<Boolean>() {
        @Override
        public void onCompleted() {
            Log.e("TAG", "onCompleted");
        }

        @Override
        public void onError(Throwable e) {
            Log.e("TAG", "onError", e);
        }

        @Override
        public void onNext(Boolean bool) {
            Log.e("TAG", "onNext");
        }
    });

怎么能达到这个目的？感谢

Answer 1

有很多方法可以做到这一点。只根据您提供的第一个伪代码提出此建议。

Observable.just(boolean)
  .flatmap( boolean -> if (boolean) return Observable3 
                       else return Observable.just(boolean))
  .flatmap(boolean -> Observable4)
  .subscribe()

Answer 2

我通过将observables定义为函数

解决了这个问题

public void run() {
    Observable
            .fromCallable(() -> false)
            .flatMap(bool -> {
                if(bool) {
                    return getObservable2();
                }
                return getObservable3();
            })
            .subscribe(bool -> {
                Log.e("TAG", "onNext");
            }, e -> {
                Log.e("TAG", "onError", e);
            }, () -> {
                Log.e("TAG", "onCompleted");
            });
}

private Observable<Boolean> getObservable2() {
    return Observable
            .just("test")
            .flatMap(s -> getObservable4());
}

private Observable<Boolean> getObservable3() {
    return Observable
            .just(1)
            .flatMap(s -> getObservable4());
}

private Observable<Boolean> getObservable4() {
    return Observable.just(true);
}

Answer 3

Observable.just(boolean)
  .flatmap( boolean -> if (boolean) 
                          return Observable3.flatmap(observable4) 
                       else return Observable4))
  .subscribe()

如果第一个observable的结果为真，则调用obervablr3，其结果然后被平面映射到observable4第二种情况，如果第一个observable的结果为false，则它将直接调用observable4，结果仅在第一个observable中订阅

Answer 4

这是我试图解决您的问题的方法，但它不使用flatmap。

Observable2.subscribe( aBoolean -> if(aBoolean){
        Observable3.subscribe();
    } else {
        Observable2.subscribe( result -> Observable3.subscribe());
}

你永远不应该从Observable

返回null

rxjava运行具有条件的多个可观察序列

4 个答案: