RxJava系列之上游与下游

系列文章

RxJava系列之简介和观察者设计模式
RxJava系列之上游与下游
RxJava系列之常用创建型操作符
RxJava系列之常用变换操作符
RxJava系列之常用过滤操作符
RxJava系列之常用条件操作符
RxJava系列之常用合并操作符
RxJava系列之常用异常操作符
RxJava系列之线程切换实战
RxJava系列之背压模式
RxJava系列之配合Retrofit
RxJava系列之泛型高级
RxJava系列之手写create操作符
RxJava系列之手写create操作符增加泛型限定
RxJava系列之手写just操作符
RxJava系列之手写map操作符
RxJava系列之手写切换线程

什么是上游和下游

在RxJava中，我们将事件的起源称之为上游，事件的处理称之为下游。上游产生事件之后，发射给下游，下游接收到并请求。如下图所示：

简单例子

/**
     * 流程整理 1
     * @param vieww
     */
    public void r04(View vieww) {

        // 上游 Observable 被观察者
        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                // 发射
                Log.d(TAG, "上游 subscribe: 开始发射..."); // todo 2
                emitter.onNext("RxJavaStudy");

                emitter.onComplete(); // 发射完成  // todo 4

                // 上游的最后log才会打印
                Log.d(TAG, "上游 subscribe: 发射完成");
            }
        }).subscribe(
         // 下游 Observer 观察者
         new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                // 弹出 加载框 ....
                Log.d(TAG, "上游和下游订阅成功 onSubscribe 1"); // todo 1
            }

            @Override
            public void onNext(String s) {
                Log.d(TAG, "下游接收 onNext: " + s); // todo 3
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {
                // 隐藏加载框
                Log.d(TAG, "下游接收完成 onComplete"); // todo 5  只有接收完成之后，上游的最后log才会打印
            }
        });

        /**
         *  D/MainActivity: 上游和下游订阅成功 onSubscribe 1
         *  D/MainActivity: 上游 subscribe: 开始发射...
         *  D/MainActivity: 下游接收 onNext: RxJavaStudy
         *  D/MainActivity: 下游接收完成 onComplete
         *  D/MainActivity: 上游 subscribe: 发射完成
         */
    }

整个流程是，上下游订阅成功，下游收到通知，处理订阅成功事件。上游在订阅成功的回调中发射事件，下游收到onNext回调，处理上游发送的事件。上游发送完成事件，下游收到onComplete回调。

另外一个例子

  /**
     * 流程整理2
     * @param vieww
     */
    public void r05(View vieww) {

        // 上游 Observable 被观察者
        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                // 发射
                Log.d(TAG, "上游 subscribe: 开始发射..."); // todo 2
                emitter.onNext("RxJavaStudy");

                // emitter.onComplete(); // 发射完成  // todo 4

                // 上游的最后log才会打印
                // Log.d(TAG, "上游 subscribe: 发射完成");

                // emitter.onError(new IllegalAccessException("error rxJava"));

                // TODO 结论：在 onComplete();/onError 发射完成 之后 再发射事件  下游不再接收上游的事件
                /*emitter.onNext("a");
                emitter.onNext("b");
                emitter.onNext("c");*/
                // 发一百个事件

                emitter.onError(new IllegalAccessException("error rxJava")); // 发射错误事件
                emitter.onComplete(); // 发射完成
                // TODO 结论：已经发射了onComplete();， 再发射onError RxJava会报错，不允许
                // TODO 结论：先发射onError，再onComplete();，不会报错， 有问题（onComplete不会接收到了）
            }
        }).subscribe(
                // 下游 Observer 观察者
                new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        // 弹出 加载框 ....
                        Log.d(TAG, "上游和下游订阅成功 onSubscribe 1"); // todo 1
                    }

                    @Override
                    public void onNext(String s) {
                        Log.d(TAG, "下游接收 onNext: " + s); // todo 3
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "下游接收 onError: " + e.getMessage());
                    }

                    @Override
                    public void onComplete() {
                        // 隐藏加载框
                        Log.d(TAG, "下游接收完成 onComplete"); // todo 5  只有接收完成之后，上游的最后log才会打印
                    }
                });

    }

在 onComplete();/onError 发射完成 之后 再发射事件 下游不再接收上游的事件
已经发射了onComplete();， 再发射onError RxJava会报错，不允许
已经发射了onComplete();， 再发射onError RxJava会报错，不允许

中断事件

Disposable d;

    /**
     * 切断下游，让下游不再接收上游的事件，也就是说不会去更新UI
     * @param view
     */
    public void r06(View view) {
        // TODO 上游 Observable
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                for (int i = 0; i < 100; i++) {
                    e.onNext(i);
                }
                e.onComplete();
            }
        })

        // 订阅下游
        .subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                MainActivity.this.d = d;
            }

            @Override
            public void onNext(Integer integer) {
                Log.d(TAG, "下游接收 onNext: " + integer);

                // 接收上游的一个事件之后，就切断下游，让下游不再接收
                // d.dispose();
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        // 切断下游
        if (d != null) d.dispose();
    }

下游在订阅成功之后onSubscribe(Disposable d) 回调方法传递过来Disposable对象，可以通过这个对象可以切断下游。