Rxandroid2.0 使用记录

简单记录一些基础知识和使用方法，目标——简单！能用！

 

Github地址：

https://github.com/ReactiveX/RxJava
https://github.com/ReactiveX/RxAndroid

 

依赖库：

implementation 'io.reactivex.rxjava2:rxjava:2.2.2'
implementation 'io.reactivex.rxjava2:rxandroid:2.1.0'

 

使用场景：异步！

实现原理：观察者模式！

 

简单用：

Observable	被观察者
Observer	观察者

不管怎么样，来个例子：

//创建被观察者
Observable.create(new ObservableOnSubscribe<String>() {
    @Override
    public void subscribe(ObservableEmitter<String> emitter) {
        emitter.onNext("G1");
        emitter.onNext("G2");
        emitter.onComplete();
    }
}).subscribe( new Observer<String>() {//创建观察者并订阅
    private Disposable mDisposable;
    @Override
    public void onSubscribe(Disposable d) {
        Log.v(TAG, "onSubscribe");
        mDisposable = d;
    }

    @Override
    public void onNext(String s) {
        Log.v(TAG, "onNext:" + s);
        if("ok".equals(s)) {
            mDisposable.dispose();
        }
    }

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

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

被观察者Observable被创建后，可以通过ObservableEmitter发数据；

观察者Observer的接口中可以收到ObservableEmitter发送的数据；

通过subscribe方法，给被观察者Observable指定观察者Observer;

数据发射器ObservableEmitter；

 

数据发射器ObservableEmitter方法有3个：

• onNext：发送数据；
• onError：发送错误消息；
• onComplete：发送完成，调用之后再调用onNext观察者Observer也不会收到消息；

数据会被发射到对应的观察者Observer的接口中；

示例中的代码，运行后LOG如下：

V/x999x: onSubscribe
V/x999x: onNext:G1
V/x999x: onNext:G2
V/x999x: onComplete

观察者Observer的onSubscribe接口会最先被调用；

而G3消息如预期一样，没有被送达；

onSubscribe接口中提供了一个Disposable对象，可以调用dispose方法中断消息发送；

修改subscribe方法代码如下：

emitter.onNext("G1");
emitter.onNext("ok");
emitter.onNext("G2");
emitter.onComplete();
emitter.onNext("G3");

再次运行后，LOG如下：

V/x999x: onSubscribe
V/x999x: onNext:G1
V/x999x: onNext:ok

调用dispose方法后，onNext和onComplete都不再执行；

最后再测试一下onError方法，修改subscribe方法代码如下：

emitter.onNext("G1");
emitter.onError(new Throwable("GOOD GAME!"));
emitter.onNext("ok");
emitter.onNext("G2");
emitter.onComplete();
emitter.onNext("G3");

再次运行后，LOG如下：

V/x999x: onSubscribe
V/x999x: onNext:G1
V/x999x: onError:java.lang.Throwable: GOOD GAME!

发送onError消息，onNext和onComplete都将不再发送；

这里需要提一点，在通过dispose中断消息后，在调用onError运行会报错！

所以调用onError消息前最好判断一下，修改subscribe方法代码如下：

emitter.onNext("G1");
emitter.onNext("ok");
if (!emitter.isDisposed()) {
    emitter.onError(new Throwable("GOOD GAME!"));
}
emitter.onNext("G2");
emitter.onComplete();
emitter.onNext("G3");

上述代码，如果去掉isDisposed会直接运行报错！

 

被观察者的创建方式：

Rxjava创建一个被观察者是第一步！

除了Observable.create以外，还有多种创建被观察者的方式：

create	最基本的创建方式，也是我们最初示例里面用的方式
just	一种快速的创建方式，直接将需要发射的内容作为参数传入，参数上限是10个；
fromArray	逐个发送传入传入的内容；和just的区别是没有上限；
fromIterable	逐个发送传入的迭代器中的元素；常见的如传入一个List作为参数；
fromPublisher	从一个Pusblisher中创建
fromCallable	从一个Callable中创建
fromFuture	从一个Future中创建

• create

最基本创建Observable的方式。这个在之前的示例中已经用到，不再重复。

• just

一种快速的创建方式，直接将需要发射的内容作为参数传入，参数上限是10个；

Observable.just(1, 2, 3)
            .subscribe(new Observer<Integer>() {
                @Override
                public void onSubscribe(Disposable d) {
                    Log("onSubscribe");
                }

                @Override
                public void onNext(Integer integer) {
                    Log("onNext-" + integer);
                }

                @Override
                public void onError(Throwable e) {
                    Log("onError");
                }

                @Override
                public void onComplete() {
                    Log("onComplete");
                }
            });

x999x:onSubscribe
x999x:onNext-1
x999x:onNext-2
x999x:onNext-3
x999x:onComplete

• fromArray

逐个发送传入传入的内容；和just的区别是没有上限；

Observable.fromArray(1, 2, 3)
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log("onSubscribe");
                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log("onNext-" + integer);
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log("onError");
                    }

                    @Override
                    public void onComplete() {
                        Log("onComplete");
                    }
                });

从这个代码来看和just没有任何区别，其实从源码看，传入多个参数的just调用的就是fromArray方法；

x999x:onSubscribe
x999x:onNext-1
x999x:onNext-2
x999x:onNext-3
x999x:onComplete

• fromIterable

逐个发送传入的迭代器中的元素；常见的如传入一个List作为参数；

List<Integer> list = new ArrayList<>();
        list.add(3);
        list.add(2);
        list.add(1);
        Observable.fromIterable(list)
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log("onSubscribe");
                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log("onNext-" + integer);
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log("onError");
                    }

                    @Override
                    public void onComplete() {
                        Log("onComplete");
                    }
                });

东西比较容易理解，所以换了一下发射的顺序，免得LOG看着像是复制粘贴的...

x999x:onSubscribe
x999x:onNext-3
x999x:onNext-2
x999x:onNext-1
x999x:onComplete

• fromPublisher

从一个Pusblisher中创建。

Rxjava中定义了很多实现Publisher接口的对象，使用Ctril+Alt+B，可以找到他们。

其中最基础的就是被观察者Flowable，和被观察者Observable的区别是支持背压式，背压式具体会在后面做介绍。

这里来个简单的例子：

Observable.fromPublisher(new Flowable<Integer>() {
            @Override
            protected void subscribeActual(Subscriber s) {
                s.onNext(3);
                s.onNext(6);
                s.onNext(9);
                s.onComplete();
            }
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log("onSubscribe");
            }

            @Override
            public void onNext(Integer integer) {
                Log("onNext-" + integer);
            }

            @Override
            public void onError(Throwable e) {
                Log("onError");
            }

            @Override
            public void onComplete() {
                Log("onComplete");
            }
        });

x999x:onNext-3
x999x:onNext-6
x999x:onNext-9
x999x:onComplete

仔细观察log，还是有一些小区别的，onSubscribe没有被调用，在使用Flowable时，onSubscribe也需要手动调用；

示例：

Observable.fromPublisher(new Flowable<Integer>() {
            @Override
            protected void subscribeActual(Subscriber s) {
                s.onSubscribe(new Subscription() {
                    @Override
                    public void request(long n) {
                        
                    }

                    @Override
                    public void cancel() {

                    }
                });
                s.onNext(3);
                s.onNext(6);
                s.onNext(9);
                s.onComplete();
            }
        }).subscribe(new Observer<Integer>() {
            //省略一长串
        }

• fromCallable

从一个Callable中创建

Callable<String> callable = new Callable<String>() {
            @Override
            public String call() throws Exception {
                Log("Callable:call");
                Thread.sleep(2000);
                return "Hello";
            }
        };
        Observable.fromCallable(callable)
                .subscribe(new Observer<String>() {
                    @Override