Question

我正在研究在当前的Android应用程序中使用RxJava / Retrofit。

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

尽管我调用了许多不同的API，但从较高的角度来看，它们可以分组为一小套Call“模式”。

例如，我所有的API调用都使用相同的Completable InitialProcess，RetryProcess和ErrorProcess。

我想做的是创建一个基类，（步骤）构建器和/或Factory解决方案，使我可以仅提供独特的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()

并返回上面显示的完整序列，然后可以使用blockingAwait()执行。

在另一个示例中

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

我会提供

uniqueCompletableProcessZ()
uniqueSingleProcessC()
uniqueCompleteProcessZ()

并返回上面显示的完整序列，然后可以使用subscribe()执行。

我尝试开发一种支持高级类型的Step Builder

这是模式步骤构建器

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();       
    }
}

和基本序列类

public class Sequence {

    protected final List<Completable> COMPLETABLES = new LinkedList<>();
    protected final List<Single<String>> SINGLES = new LinkedList<>();

    public Sequence() {
        COMPLETABLES.clear();
        SINGLES.clear();

        COMPLETABLES.add(getCommonInitialProcess());
    }


    /**
     * @return
     * 
     */
    private Completable getCommonInitialProcess() {
        return Completable.create(new CompletableOnSubscribe() {

            @Override
            public void subscribe(final CompletableEmitter emitter) throws Exception {
                Thread.sleep(500);
                System.out.println("CommonInitialProcess()");
                emitter.onComplete();
            }
        });

    }

}

哪个有效，但是它的使用仍然“笨拙”

FigurateSequence.builder().first(getUniqueCompletableProcess_A()).second(getUniqueSingleProcess_A()).build().execute();

但是，有些情况仍然很麻烦

例如当我同时具有默认和自定义的“步骤序列”时。

例如，如果我有默认的DoOnError()和自定义的DoOnError()，如何定义步骤构建器的内部接口来应对“可选”步骤？

为常见的RxJava阶段开发RxJava基类/工厂类

0 个答案: