RxJava2.0笔记

基础知识

---

角色关系（1.x）

Observable（被观察者，事件源）
Subscribe（订阅动作）
Observer（观察者）/Subscriber（订阅者）

三者关系：
现实中——观察者/订阅者 订阅 事件
RxJava中——obervable.subscribe(observer/subscriber)-->返回Subscription对象
两者相反，需注意

---

回调方法

在RxJava中，有三个回调方法，onNext(),onError()和onCompelete().。onNext()是最终输出及处理数据的回调，在发射数据过程中出现错误异常会回调OnError()方法，当不会再有新的 onNext() 发出时，需要触发 onCompleted() 方法作为标志。,OnError()和onCompleted()是互斥的。下面举一个最简单的例子：

        Observable observable2 = Observable.just("也许当初忙着微笑和哭泣", "忙着追逐天空中的流星", "人理所当然的忘记", "是谁风里雨里一直默默守护在原地");
        Subscriber subscriber = new Subscriber() {
            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted: " )
            }

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

            @Override
            public void onNext(String s) {
               Log.e(TAG, "onNext: "+s )
            }
        };
        observable.subscribe(subscriber);

运行结果为：

onNext: 也许当初忙着微笑和哭泣
onNext: 忙着追逐天空中的流星
onNext: 人理所当然的忘记
onNext: 是谁风里雨里一直默默守护在原地
onCompleted:

---

RxJava2.x

RxJava 2.0开发文档

1.x->2.x的详细细节变化

RxJava 2x 不再支持 null 值，如果传入一个null会抛出 NullPointerException

Observable升级为Flowable ,Flowable是Publisher的子类，解决MissingBackpressureException异常
在2.x中，添加了Flowable来支持背压，而把Observable设计成非背压的
Subscriber回调方法中新增onSubscribe(Disposable s)方法。Disposable就是1.x中的Subscription，只是为了避免冲突而改名的。
在2.x中，我们在onSubscribe()回调中必须调用s.request()方法去请求资源，参数就是要请求的数量，一般如果不限制请求数量，可以写成Long.MAX_VALUE，之后会立即触发onNext()方法！
以下粗斜体部分为引用别人文章的内容：所以当你在onSubscribe()/onStart()中做了一些初始化的工作，而这些工作是在request()后面时，会出现一些问题，在onNext()执行时，你的初始化工作的那部分代码还没有执行。为了避免这种情况，请确保你调用request()时，已经把所有初始化工作做完了。

先写一个最简单的常规写法：

//创建订阅者
Subscriber subscriber = new Subscriber() {
    @Override
    public void onSubscribe(Subscription s) {
    //这一步是必须，我们通常可以在这里做一些初始化操作，调用request()方法表示初始化工作已经完成
    //调用request()方法，会立即触发onNext()方法
    //在onComplete()方法完成，才会再执行request()后边的代码
    s.request(Long.MAX_VALUE);
    }

    @Override
    public void onNext(String value) {
        Log.e("onNext", value);
    }

    @Override
    public void onError(Throwable t) {
        Log.e("onError", t.getMessage());
    }

    @Override
    public void onComplete() {
    //由于Reactive-Streams的兼容性，方法onCompleted被重命名为onComplete
        Log.e("onComplete", "complete");
    }
};

Flowable.create(new FlowableOnSubscribe() {
    @Override
    public void subscribe(FlowableEmitter e) throws Exception {
        e.onNext("Hello,I am DoggieX!");
    }
}, BackpressureStrategy.BUFFER)
    .subscribe(subscriber);     

BackpressureStrategy为背压，该参数需要传入一个背压模式，关于背压这个知识点，看不太懂，哈哈！背压知识点传送门
总之就是解决被观察者发送消息太快导致观察者来不及做处理的策略，这也就是Flowable存在的原因。（Observable不支持背压）

接下来分析一下新增的onSubcribe方法和request方法。
首先贴上测试代码，看着代码来分析：

        Subscriber subscriber = new Subscriber() {

            @Override
            public void onSubscribe(Subscription s) {
                Log.e(TAG, "初始化");
//                s.request(Long.MAX_VALUE);
                s.request(2);
                Log.e(TAG, "初始化2");
            }

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

            @Override
            public void onError(Throwable t) {

            }

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

        Flowable.create(new FlowableOnSubscribe() {
            @Override
            public void subscribe(FlowableEmitter e) throws Exception {
                e.onNext("第一句话");
                e.onNext("第二句话");
                e.onNext("第三句话");
                e.onComplete();
            }
        }, BackpressureStrategy.BUFFER)
                //1.x中subscribe返回Subscription对象   2.x中返回void  若要返回值  使用subscribeWith方法
                .subscribe(subscriber);

测试结果：

E/RxTest: 初始化
E/RxTest: 初始化2
E/RxTest: onNext:第一句话
E/RxTest: onNext:第二句话

根据结果并结合上文标识为粗斜体部分的引用文，我们能够得出两个结论：

1. onSubscribe中的代码的确是在onNext方法之前执行的。但是与上文不同的是，request方法之后的初始化代码依然在onNext之前执行，总之最后写request是准没错的。
2. request(long n) n参数代表了回调的限制次数 若n=2，flowable最多只会执行两次onNext方法，甚至不会调用onComplete方法，若不需要作此限制 可将n=Long.MaxValue。如果不调用request,onNext和onComplete方法将不会被调用。

当我们仅仅只关心onNext方法时，1.x中我们的做法是使用Action1-9来实现多个参数的简洁实现。而在2.x中使用Consumer来代替Action1，如果是两个参数，则用BiConsumer来代替Action2，并且删除了Action3-9，如果是多个参数则用Custom代替ActionN。

测试一下最简单的Consumer：

        Flowable.fromArray(new String[]{"Hello","I","am","DoggieX"})
                .subscribe(new Consumer() {
                    @Override
                    public void accept(String s) throws Exception {
                        Log.e(TAG, s);
                    }
                });

结果：

E/RxTest: Hello
E/RxTest: I
E/RxTest: am
E/RxTest: DoggieX

具体使用需以后结合操作符体现。

---

基础操作符

---

• from（1.x）

该操作符是将其它种类的对象和数据类型转换为Flowable，如果当你发射的的数据是同一种类型，而不是混合使用Flowables和其它类型的数据，会非常方便。
因为在使用java8编译时，javac不能够区分功能接口类型，所以它在2.x中被拆分为：fromArray,fromIterable,fromFuture
fromFuture(Future future, long timeout, TimeUnit unit)指定超时时间，如果执行的时候Future超时会回调onError()方法。

        Flowable.fromArray(new Integer[]{1, 0, 2, 4})
                .subscribe(new Consumer() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.e(TAG, "integer:" + integer);
                    }
                });

结果：

E/RxTest: integer:1
E/RxTest: integer:0
E/RxTest: integer:2
E/RxTest: integer:4

---

• just

from会将数组或Iterable的数据取出然后逐个发射，而Just只是简单的原样发射，但也可以传入多个数据（甚至多个类型）逐个发送。

        Flowable.just(1, "0", 2, "4", "1024")
                .subscribe(new Consumer() {
                    @Override
                    //传入类型需有一个统一的返回类型   例如实现统一接口Serializable  或者有共同父类
                    public void accept(Serializable serializable) throws Exception {
                        Log.e(TAG, serializable.toString());
                    }
                });

输出结果：

E/RxTest: 1
E/RxTest: 0
E/RxTest: 2
E/RxTest: 4
E/RxTest: 1024

---

• Empty/Never/Error

Empty:创建一个不发射任何数据但是正常终止的Observable，此时会回调onCompleted（）

Never:创建一个不发射数据也不终止的Observable

Error:创建一个不发射数据以一个错误终止的Observable

error操作符需要一个Throwable参数，你的Observable会以此终止。这些操作符默认不在任何特定的调度器上执行，但是empty和error有一个可选参数是Scheduler，如果你传递了Scheduler参数，它们会在你指定的调度器上发送通知。

Empty操作符测试：

Flowable.empty().subscribe(new Subscriber