RxJava基础知识点总结

代码实现

场景1：被观察者、观察者和订阅分开写

       /**
         * 先创建一个上游Observable
         * 角色：被观察者
         */
        Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("hello");
                emitter.onNext("world");
                emitter.onNext("!");

                emitter.onNext("welcome");
                emitter.onNext("here");
                emitter.onComplete();
            }
        });

       /**
         * 创建一个下游Observer
         * 角色：观察者
         */
        Observer<String> observer = new Observer<String>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {
                Log.d(TAG, "subscribe start");
            }

            @Override
            public void onNext(@NonNull String s) {
                Log.d(TAG, "received content is : " + s);
            }

            @Override
            public void onError(@NonNull Throwable e) {
                Log.d(TAG, "error is : " + e.getMessage());
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "subscribe complete");
            }
        };

//建立连接（上游订阅下游）
observable.subscribe(observer);

场景2：被观察者、观察者和订阅一起写

Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("hello");
                emitter.onNext("world");
                emitter.onNext("!");

                emitter.onNext("welcome");
                emitter.onNext("here");
                emitter.onComplete();
            }
        }).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(@NonNull Disposable disposable) {
                Log.d(TAG, "subscribe start");
            }

            @Override
            public void onNext(@NonNull String s) {
                Log.d(TAG, "received content is : " + s);
            }

            @Override
            public void onError(@NonNull Throwable e) {
                Log.d(TAG, "error is : " + e.getMessage());
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "subscribe complete");
            }
        });
    }

关于ObservableEmitter

ObservableEmitter，顾名思义被观察者的发射器。听着有点滑稽，实际上它就是一个发射器，用于从上游发射要传送的数据或者控制信息到下游。
ObservableEmitter的源代码如下所示。

public interface ObservableEmitter<T> extends Emitter<T> {

    void setDisposable(@Nullable Disposable d);

    void setCancellable(@Nullable Cancellable c);

    boolean isDisposed();

    @NonNull
    io.reactivex.ObservableEmitter<T> serialize();

    @Experimental
    boolean tryOnError(@NonNull Throwable t);
}

ObservableEmitter接受泛型数据，并且继承了一个更加底层的接口Emitter，索性再看看Emitter类的源码。

public interface Emitter<T> {

    void onNext(@NonNull T value);

    void onError(@NonNull Throwable error);

    void onComplete();
}

下面简要介绍下重点的几个方法。
1） onNext(@NonNull T value)方法
这个方法就是最关键的方法了，当被观察者和观察者建立了连接。那么，正常情况下只要没有发生错误或者连接被废弃的话。上游（被观察者）就会通过这个方法往下游（观察者）传递消息，下游 会在onNext方法中接受到消息，进行相应的处理。

2）onError(@NonNull Throwable error)方法
这个方法一般是在发生错误时，上游会将错误信息封装在Throwable中抛给下游，下游会在onError方法中接受到错误信息进行相应的错误处理。
这里需要格外注意的是：当emitter抛出错误时，连接将中断，后面再进行onNext(@NonNull T value)也不会得到任何回应了。另外，onError(@NonNull Throwable error)方法也只会调用一次，写100个onError(@NonNull Throwable error)也只有第一个会调用。后面的不但不会调用，还会出错。

3）onComplete()方法
改方法调用后，下游会在onComplete()方法中回应，上下游的连接即可中断。上游再调用onNext(@NonNull T value)方法也不会得到任何回应了。onComplete()方法也是只调用一次，而且跟onError是互斥的，他俩都可以即可中断连接。