RxJava中关键的类

Observable

Observable 是第一个核心类。该类包含了 Rx 中的很多实现,以及所有核心的操作函数(operator、或者说 操作符)。

Observer/Consumer

Observer是一个接口,定义了onSubscribe(),onNext(),onError(),onComplete()可以操作Observable 发射的事件流
Subscriber 是 Observer 的一个实现。 Subscriber 实现了其他一些额外的功能,可以作为我们实现 Observer 的基类。

Subject

Subject 是 Observable 的一个扩展,同时还实现了 Observer 接口。第一眼看上去可能有点奇怪,但是在有些场合下使用 Subject 将会非常便捷。他们可以像 Observer 一样接收事件,同时还可以像 Observable 一样把接收到的事件再发射出去。这种特性非常适合 Rx 中的接入点,当你的事件来至于 Rx 框架之外的代码的时候,你可以把这些数据先放到 Subject 中,然后再把 Subject转换为一个 Observable,就可以在 Rx 中使用它们了。你可以把 Subject 当做 Rx 中的 事件管道。

subscribe()

subscribe()是联系Observable和Observer的桥梁。

使用RxJava的基本流程

1.创建Observable

Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
                try {
                    e.onNext("A");
                    e.onNext("A");
                    e.onNext("A");
                    e.onComplete();
                } catch (Exception ex) {
                    e.onError(ex);
                }

            }
        });

2.创建Observer

Observer observer = new Observer<String>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {
                Log.i(TAG, "onSubscribe: ");
            }

            @Override
            public void onNext(@NonNull String s) {
                Log.i(TAG, "onNext: s = " + s);
            }

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

            @Override
            public void onComplete() {
                Log.i(TAG, "onComplete: ");
            }
        };

3.subscribe()
subscribe()有多个重载的方法:

    public final Disposable subscribe(Consumer<? super T> onNext) {}
    public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError) {} 
    public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete) {}
    public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Consumer<? super Disposable> onSubscribe) {}
    public final void subscribe(Observer<? super T> observer) {}
  • 不带任何参数的subscribe() 表示下游不关心任何事件
  • 带有一个Consumer参数的方法表示下游只关心onNext事件, 其他的事件我假装没看见, 因此我们如果只需要onNext事件可以这么写:
Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                Log.d(TAG, "emit 1");
                emitter.onNext(1);
                Log.d(TAG, "emit 2");
                emitter.onNext(2);
                Log.d(TAG, "emit 3");
                emitter.onNext(3);
                Log.d(TAG, "emit complete");
                emitter.onComplete();
                Log.d(TAG, "emit 4");
                emitter.onNext(4);
            }
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.d(TAG, "onNext: " + integer);
            }
        });
  • 其余同理
    这里我们使用最后一个
observable.subscribe(observer);

运行结果:

08-24 08:03:25.041 6134-6134/com.example.wty.learnrxjava I/MainActivity: onSubscribe: 
08-24 08:03:25.042 6134-6134/com.example.wty.learnrxjava I/MainActivity: onNext: s = A
08-24 08:03:25.042 6134-6134/com.example.wty.learnrxjava I/MainActivity: onNext: s = B
08-24 08:03:25.042 6134-6134/com.example.wty.learnrxjava I/MainActivity: onNext: s = C
08-24 08:03:25.042 6134-6134/com.example.wty.learnrxjava I/MainActivity: onComplete: 

4.链式调用

 Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
                try {
                    e.onNext("A");
                    e.onNext("B");
                    e.onNext("C");
                    e.onComplete();
                } catch (Exception ex) {
                    e.onError(ex);
                }
            }
        }).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {
                Log.i(TAG, "onSubscribe: ");
            }

            @Override
            public void onNext(@NonNull String s) {
                Log.i(TAG, "onNext: s = " + s);
            }

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

            @Override
            public void onComplete() {
                Log.i(TAG, "onComplete: ");
            }
        });

ObservableEmitter和Disposable

ObservableEmitter: Emitter是发射器的意思,那就很好猜了,这个就是用来发出事件的,它可以发出三种类型的事件,通过调用emitter的onNext(T value)、onComplete()和onError(Throwable error)就可以分别发出next事件、complete事件和error事件。
但是,请注意,并不意味着你可以随意乱七八糟发射事件,需要满足一定的规则:
上游可以发送无限个onNext, 下游也可以接收无限个onNext.

  • 当上游发送了一个onComplete后, 上游onComplete之后的事件将会继续发送, 而下游收到onComplete事件之后将不再继续接收事件.
  • 当上游发送了一个onError后, 上游onError之后的事件将继续发送, 而下游收到onError事件之后将不再继续接收事件.
  • 上游可以不发送onComplete或onError.
  • 最为关键的是onComplete和onError必须唯一并且互斥, 即不能发多个onComplete, 也不能发多个onError, 也不能先发一个onComplete, 然后再发一个onError, 反之亦然

关于onComplete和onError唯一并且互斥这一点, 是需要自行在代码中进行控制, 如果你的代码逻辑中违背了这个规则, 并不一定会导致程序崩溃. 比如发送多个onComplete是可以正常运行的, 依然是收到第一个onComplete就不再接收了, 但若是发送多个onError, 则收到第二个onError事件会导致程序会崩溃。

介绍了ObservableEmitter, 接下来介绍Disposable, 这个单词的字面意思是一次性用品,用完即可丢弃的. 那么在RxJava中怎么去理解它呢,对应于观察者模式相当于取消订阅, 对应于上面的水管的例子, 我们可以把它理解成两根管道之间的一个机关, 当调用它的dispose()方法时, 它就会将两根管道切断, 从而导致下游收不到事件.

注意: 调用dispose()并不会导致上游不再继续发送事件, 上游会继续发送剩余的事件.

来看个例子, 我们让上游依次发送1,2,3,complete,4,在下游收到第二个事件之后, 切断水管, 看看运行结果:

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
                e.onComplete();
                e.onNext(4);
            }
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {
                Log.i(TAG, "onSubscribe: ");
                disposable = d;
            }

            @Override
            public void onNext(@NonNull Integer integer) {
                Log.i(TAG, "onNext: integer = " + integer);
                if (integer == 2) {
                    disposable.dispose();
                }
            }

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

            @Override
            public void onComplete() {
                Log.i(TAG, "onComplete: ");
            }
        });
08-24 16:27:15.856 25856-25856/com.example.wty.learnrxjava I/MainActivity: onSubscribe: 
08-24 16:27:15.857 25856-25856/com.example.wty.learnrxjava I/MainActivity: onNext: integer = 1
08-24 16:27:15.857 25856-25856/com.example.wty.learnrxjava I/MainActivity: onNext: integer = 2

推荐阅读更多精彩内容