RXJava入门总结以及简易Demo

Rxjava由于其基于事件流的链式调用、逻辑简洁 & 使用简单的特点，深受各大 Android开发者的欢迎

在android开发框架中:RxJava+Retrofit+MVP+Dagger2（主流框架)中Rxjava是对网络连接处理和图片加载处理非常好用的异步操作方法，类似于Android中的AysncTask、Handler

Rxjava的模式类似于Java的观察者模式

被观察者：Observable

观察者：Observer

通过订阅来关联观察者和被观察者：Subscribe

然后我觉得比较重要在线程切换方面的两个方法的区别：

ObserveOn

指定一个观察者在哪个调度器上观察这个Observable

SubscribeOn

指定Observable自身在哪个调度器上执行

补充：对事件总线有理解的的，还可以去查看一下RxBus来看一下Rxjava的事件总线处理机制

下面通过一个demo来简易介绍Rxjava怎么使用：

开发的IDE是android studio ，如果你是eclipse请点右上角的X

build.grade(app)中添加依赖：

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

第一个Demo是将被观察者和观察者和订阅都分开写。

创建被观察者：

 Observable observable = Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
                e.onNext(4);//要发送的事件
            }
        });//创建被观察者

创建观察者

  Observer observer = new Observer() {
            private Disposable mDisposable;
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "开始采用subscribe连接");
                mDisposable = d;
            }

            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "对Next事件" + value + "作出相应");
                if(value == 2){
                    mDisposable.dispose();
                    Log.d(TAG,"已经断开连接:"+mDisposable.isDisposed());
                }
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "对Error事件作出响应");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "对Complete事件作出响应");
            }
        };

补充：代码中有一行这个代码解释一下

            private Disposable mDisposable;

这个代码是订阅者和被订阅者的关系断开的一个控制变量。

取消订阅：

mDisposable.dispose();

取消订阅后，观察者就无法在接受被观察者发来的信息了

将被观察者和观察者通过订阅关系绑定

observable.subscribe(observer);

但是上面的代码，从字面上理解是被观察者订阅观察者，从字面上理解有问题，其实从机制上来说没问题，我个人的理解就是观察者相当于一个接收器，而被观察者是发起消息的发送器，发送器来绑定一个接受器这样的逻辑，如果不对，还请多多指教。

下面是Rxjava典型的链式结构：

Observable.create(new ObservableOnSubscribe() {
           @Override
           public void subscribe(ObservableEmitter e) throws Exception {
               e.onNext(1);
               e.onNext(2);
               e.onNext(3);
               e.onNext(4);
           }
       }).subscribe(new Observer() {
           @Override
           public void onSubscribe(Disposable d) {
               Log.d(TAG,"开始采用subscribe连接");
           }

           @Override
           public void onNext(Integer value) {
                Log.d(TAG,"对Next事件"+value+"作出响应");
           }

           @Override
           public void onError(Throwable e) {
                Log.d(TAG,"对ERROR事件作出响应");
           }

           @Override
           public void onComplete() {
                Log.d(TAG,"对Complete事件作出响应");
           }
       });