Rx java 如何以RxJava方式实现多步骤向导？

我试图在RxJava中实现一些多步骤使用向导。为了简化这个案例，假设用户只能进入下一步，而不能后退

我在考虑将每个步骤建模为一个可观察的对象，当用户订阅时，该对象将呈现自身，当用户选择进入下一步时，该对象将完成自身。所以会有第1步，第2步，等等

然后向导控制器的逻辑将如下所示 1） 订阅步骤1\u可观察 2） 当step1_Observable完成时，订阅step2_Observable 3） 当step2_Observable完成时，订阅step3_Observable 诸如此类

有人可能会想，为什么我不能将下一步按钮单击事件建模为一个可观察事件，然后订阅它以呈现下一步呢。原因是，在我的设计中，每个步骤都有自己独特的方法供用户导航到下一页。例如，可能是触摸屏上的特定手势，甚至可能是正确回答测验

---

我不知道如何通过Rx提供的操作实现这一点。有什么想法吗？

flatMap

用于按顺序运行

Observable

s。下面是一个示例，演示如何在一些可观察对象完成后运行可观察对象：

public Observable<String> step1() {
    return null;
}

public Observable<String> step2() {
    return null;
}

public Observable<String> step3() {
    return null;
}

public Observable<String> chainSteps(final Observable<String> first, final Observable<String> second) {
    return first.flatMap(new Func1<String, Observable<String>>() {

        @Override
        public Observable<String> call(String s) {
            return Observable.empty();
        }
    }, new Func1<Throwable, Observable<String>>() {

        @Override
        public Observable<String> call(Throwable e) {
            return Observable.error(e);
        }
    }, new Func0<Observable<String>>() {

        @Override
        public Observable<String> call() {
            return second;
        }
    });
}

public void example() {
    chainSteps(chainSteps(step1(), step2()), step3()).subscribe(...);
}

---

谢谢你的解决方案。我不知道flatMap有一个变体，它允许在onComplete回调中返回一个新的可观察对象。很高兴听到这个提示。在您的解决方案中，有一件事我不是特别喜欢——我们必须嵌套chainSteps调用。如果我们的步骤超过3步，那么If将很笨拙。不确定是否有更好的解决方案。我更新了答案。您可以使用

compose

和

Transformer

使代码更干净。

public class ChainTransformer<T> implements Observable.Transformer<T, T> {

    private final Observable<T> other;

    public ChainTransformer(Observable<T> other) {
        this.other = other;
    }

    @Override
    public Observable<? extends T> call(Observable<? extends T> observable) {
        return observable.flatMap(new Func1<T, Observable<T>>() {

            @Override
            public Observable<T> call(T s) {
                return Observable.empty();
            }
        }, new Func1<Throwable, Observable<T>>() {

            @Override
            public Observable<T> call(Throwable e) {
                return Observable.error(e);
            }
        }, new Func0<Observable<T>>() {

            @Override
            public Observable<T> call() {
                return other;
            }
        });
    }
}

public void example() {
    step1().compose(new ChainTransformer<String>(step2()))
            .compose(new ChainTransformer<String>(step3()));
}