为通用RxJava阶段开发RxJava基类/工厂类

我正在调查在我当前的Android应用程序中使用RxJava/改型的情况

我的Android应用程序必须支持许多RestFul Web服务调用，以维护用户和参考数据

尽管我调用了许多不同的API，但在较高的级别上，它们可以被分组为一小组调用“模式”

例如，我所有的API调用都使用相同的

Completable

InitialProcess、RetryProcess和ErrorProcess

我想做的是创建一个基类、（Step）生成器和/或工厂解决方案，它允许我只提供唯一的RxJava阶段，并将它们与上面提到的“公共”阶段结合起来

解决方案将允许我指定

subscribeOn（）

/

observeOn（）

，并允许我选择

blockingWait（）

或

subscribe（）

等

例如，假设我需要以下操作顺序：-

  commonInitialProcess()
                .andThen(Completable.defer(() -> uniqueCompletableProcessX()))
                .andThen(Single.defer(() -> uniqueSingleProcessA())))
                .doOnSuccess(commonSuccessProcess())
                .ignoreElement()
                .andThen(Single.defer(() -> uniqueSingleProcessB())))
                .doOnSuccess(commonSuccessProcess())
                .ignoreElement()
                .andThen(uniqueCompletableProcessY())
                .retryWhen(commonRetryWhenProcess())
                .doOnComplete(uniqueCompleteProcess())
                .doOnError(commonErrorProcess())
                .blockingAwait();

我会提供

uniqueCompletableProcessX()
uniqueSingleProcessA()
uniqueSingleProcessB()
uniqueCompletableProcessY()
uniqueCompleteProcess()

uniqueCompletableProcessZ()
uniqueSingleProcessC()
uniqueCompleteProcessZ()

然后，我可以使用

blockingAwait（）

执行上面显示的完整序列

在另一个例子中

 commonInitialProcess()
                .andThen(Completable.defer(() -> uniqueCompletableProcessZ()))
                .andThen(Single.defer(() -> uniqueSingleProcessC())))
                .doOnSuccess(commonSuccessProcess())
                .retryWhen(commonRetryWhenProcess())
                .doOnComplete(uniqueCompleteProcessZ())
                .doOnError(commonErrorProcess())
                .subscribe();

我会提供

uniqueCompletableProcessX()
uniqueSingleProcessA()
uniqueSingleProcessB()
uniqueCompletableProcessY()
uniqueCompleteProcess()

uniqueCompletableProcessZ()
uniqueSingleProcessC()
uniqueCompleteProcessZ()

然后，我可以使用

subscribe（）

执行上面显示的完整序列

我尝试开发一个步骤生成器来支持高级类型

这是模式步骤生成器

public class FigurateSequence extends Sequence {

    private static final int COMMON_INITIAL_PROCESS = 0;
    private static final int UNIQUE_COMPLETABLE_STEP_A = 1;

    private static final int UNIQUE_SINGLE_STEP_B = 0;

    public FigurateSequence(final FigurateSequenceBuilder figurateSequenceBuilder) {
        COMPLETABLES.addAll(figurateSequenceBuilder.getCompletables());
        SINGLES.addAll(figurateSequenceBuilder.getSingles());
    }

    public static Step_0001 builder() {
        return new FigurateSequenceBuilder();
    }

    public interface Step_0001 {
        Step_0002 first(final Completable completable);
    }

    public interface Step_0002 {
        Build second(final Single<String> single);
    }

    public interface Build {
        FigurateSequence build();
    }

    public static class FigurateSequenceBuilder implements Step_0001, Step_0002, Build {

        private final List<Completable> completables = new LinkedList<>();
        private final List<Single<String>> singles = new LinkedList<>();

        /**
         * 
         */
        private FigurateSequenceBuilder() {

        }

        @Override
        public Step_0002 first(final Completable completable) {
            completables.add(completable);
            return this;
        }

        @Override
        public Build second(final Single<String> single) {
            singles.add(single);
            return this;
        }

        @Override
        public FigurateSequence build() {
            return new FigurateSequence(this);
        }

        /**
         * @return the completables
         */
        public List<Completable> getCompletables() {
            return completables;
        }

        /**
         * @return the singles
         */
        public List<Single<String>> getSingles() {
            return singles;
        }
    }

    public void execute() {

        COMPLETABLES.get(COMMON_INITIAL_PROCESS)
        .andThen(Completable.defer(() -> COMPLETABLES.get(UNIQUE_COMPLETABLE_STEP_A)))
        .andThen(Single.defer(() -> SINGLES.get(UNIQUE_SINGLE_STEP_B)))
        .subscribe();       
    }
}

然而，也有一些案例仍然很麻烦

例如，当我有一个默认的和自定义的“步骤序列”

---

例如，如果我有一个默认的

DoOnError（）

和一个自定义的

DoOnError（）

如何定义我的步骤生成器内部接口来处理一个“可选”步骤？

您设计了一个不太必要的解决方案。因为这些观察者链本身就是“建设者”，所以您主要是在重新发明轮子。与其重新发明构建器模式，不如花时间创建单元测试，以测试所有组件是否都存在于观察者链中。