Rxjava2.0学习笔记（一）

吐槽

突然写完游戏，，不知道安卓自己要学什么，明明自己安卓方面还是什么都不会，但有点迷，就最近学下Rxjava2.0,因为可能他在网络这块用处大，自己也要继续把自己的卡片项目写完，java的相关知识也要跟上学习。

什么是Rxjava2.0

RxJava 是一个 基于事件流、实现异步操作的库
由于 RxJava的使用方式是：基于事件流的链式调用，所以使得 RxJava
更重要的是，随着程序逻辑的复杂性提高，它依然能够保持简洁 & 优雅
自己觉得写链式调用很优雅哈
感觉代码真的很舒服，，，不像自己写的代码和狗啃了一样

使用Rxjava2.0

Android中使用RxJava2, 先添加Gradle配置:

compile 'io.reactivex.rxjava2:rxjava:2.0.1'
compile 'io.reactivex.rxjava2:rxandroid:2.0.1'

Rxjava2.0的简单原理

看了好多人的博客，，，上来就是什么观察者，被观察者，自己一脸懵逼，然后简书上有个大佬写的Rxjava的文章系列真的是通俗易懂，自己就按大佬的脚步学习吧。

就像一条河流一样，上游的人在发消息，下游的人接收消息
上游的人发的消息的编号是1，2，3，按照编号顺序发出去1号先发，接着2号，最后3号
下游的人接收时候顺序也就是1，2，3
//谁先发，谁先被接收

上游发信息的就是被观察者 Observable
下游接收消息的就是观察者 Observer
事件就是发的消息 Event
它们之间的连接就对应着就叫订阅 subscribe

简单的Demo

逻辑很简单
第一步：创建被观察者，发送数据

      //创建一个上游   创建被观察者(Observable) & 定义需发送的事件
        Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
            // 通过 ObservableEmitter类对象产生事件并通知观察者
            // ObservableEmitter类介绍
            // a. 定义：事件发射器
            // b. 作用：定义需要发送的事件 & 向观察者发送事件

            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                Log.d("233","emit 1");
                e.onNext(1);
                Log.d("233","emit 2");
                e.onNext(2);
                Log.d("233","emit 3");
                e.onNext(3);
                e.onComplete();//发送完毕

            }
        });

第二步：创建观察者，接收数据

  //创建一个下游= 创建观察者(Observer) & 定义响应事件的行为 
        Observer<Integer> observer = new Observer<Integer>() {

            @Override
            public void onSubscribe(Disposable d) {
                Log.d("233", "subscribe");
            }

            @Override
            //连续发的
            public void onNext(Integer value) {
                Log.d("233","onNext "+value);
            }

            @Override
            //发送错误的
            public void onError(Throwable e) {
                Log.d("233","error");

            }

            @Override
            //完成的
            public void onComplete() {
                Log.d("233","complete");

            }
        };

第三步：把观察者和被观察者连接在一起

//建立连接
observable.subscribe(observer);

这样就接收到上游发的消息了

链式方法书写：整体方法调用顺序：观察者.onSubscribe（）> 被观察者.subscribe（）> 观察者.onNext（）>观察者.onComplete()

  Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                Log.d("233","emit 1");
                e.onNext(1);
                Log.d("233","emit 2");
                e.onNext(2);
                Log.d("233","emit 3");
                e.onNext(3);
                e.onComplete();
            }
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d("233", "subscribe");
            }

            @Override
            public void onNext(Integer value) {
                Log.d("233","onNext "+value);

            }

            @Override
            public void onError(Throwable e) {
                Log.d("233","error");

            }

            @Override
            public void onComplete() {
                Log.d("233","complete");

            }
        });

这样写真的很舒服

截断消息发送 Disposable.dispose()

观察者 无法继续 接收 被观察者的事件，但被观察者还是可以继续发送事件
在观察者函数里面安排这个

  Observer<Integer> observer = new Observer<Integer>() {
            private Disposable mDisposable;//截断器
            private int i;//截断的点

            @Override
            public void onSubscribe(Disposable d) {
                Log.d("233", "subscribe");
                mDisposable = d;
            }

            @Override
            //连续发的
            public void onNext(Integer value) {
                Log.d("233","onNext "+value);
                i++;
                if (i==2){
                    mDisposable.dispose();//截断
                    Log.d("233",mDisposable.isDisposed()+"");
                }

            }

然后就发行被观察者还是发了3个
但是接收者只是接收了前两个

发送和接收时候注意点

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, 反之亦然

观察者 Observer的subscribe()多个重载的方法

可以根据这个灵活使用

public final Disposable subscribe() {} // 表示观察者不对被观察者发送的事件作出任何响应（但被观察者还是可以继续发送事件）
public final Disposable subscribe(Consumer<? super T> onNext) {}  // 表示观察者只对被观察者发送的Next事件作出响应
public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError) {} // 表示观察者只对被观察者发送的Next事件 & Error事件作出响应
public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete) {} // 表示观察者只对被观察者发送的Next事件、Error事件 & Complete事件作出响应
public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Consumer<? super Disposable> onSubscribe) {} // 表示观察者只对被观察者发送的Next事件、Error事件 、Complete事件 & onSubscribe事件作出响应
 public final void subscribe(Observer<? super T> observer) {}   // 表示观察者对被观察者发送的任何事件都作出响应

总结

自己这两天看下这个，学习下，顺便用到自己项目里面
csdn有毒啊，，，图片发不了
自己参考的大佬博客
大佬博客地址