Android框架|异步-Rxjava2.x(二)

RxJava的简单使用

1.初始化 Observable
2.初始化 Observer
3.建立订阅关系

添加依赖

compile 'io.reactivex.rxjava2:rxjava:2.2.1'
compile 'io.reactivex.rxjava2:rxandroid:2.1.0'

---

代码实现：

Observable.create(new ObservableOnSubscribe<Integer>() { 
// 第一步：初始化Observable
//决定什么时候触发事件以及触发怎样的事件
            @Override
            public void subscribe(@NonNull ObservableEmitter<Integer> e) throws Exception {
                Log.e(TAG, "Observable发射 1" + "\n");
                e.onNext(1);
            }
        }).subscribe(new Observer<Integer>() {
        // 第二步：初始化Observer，决定事件触发的时候将有怎样的行为
            // 第三步：订阅，联系起来
        @Override
        public void onSubscribe(@NonNull Disposable d) {
            Log.e(TAG, "调用onSubscribe"+"\n" );
        }

        @Override
        public void onNext(@NonNull Integer integer) {
            Log.e(TAG, "调用onNext : value : " + integer + "\n" );
        }

        @Override
        public void onError(@NonNull Throwable e) {
            Log.e(TAG, "调用onError : value : " + e.getMessage() + "\n" );
        }

        @Override
        public void onComplete() {
            Log.e(TAG, "调用onComplete" + "\n" );
        }
    });

• Observable 和 Observer 通过 subscribe() 方法实现订阅关系，从而 Observable
  可以在需要的时候发出事件来通知 Observer。

常见操作符

• create
  主要用于产生一个 Obserable 被观察者对象。

  Observable.create(new ObservableOnSubscribe<Integer>() {
          @Override
          public void subscribe(@NonNull ObservableEmitter<Integer> e) throws Exception {
              Log.e(TAG, "Observable发射 1" + "\n");
              e.onNext(1);
              e.onComplete();
              Log.e(TAG, "Observable发射 2" + "\n");
              e.onNext(2);
              Log.e(TAG, "Observable发射 3" + "\n");
              e.onNext(3);
              Log.e(TAG, "Observable发射 4" + "\n" );
              e.onNext(4);
          }
      }).subscribe(new Observer<Integer>() {
          private int i;
          private Disposable mDisposable;
  
          @Override
          public void onSubscribe(@NonNull Disposable d) {
              Log.e(TAG, "调用onSubscribe，是否调用 isDisposed :" + d.isDisposed() + "\n" );
              mDisposable = d;
          }
  
          @Override
          public void onNext(@NonNull Integer integer) {
              Log.e(TAG, "调用onNext : value : " + integer + "\n" );
              i++;
              if (i == 2) {
                  // 在RxJava 2.x 中，新增的Disposable可以做到切断的操作，让Observer观察者不再接收上游事件
                  mDisposable.dispose();
                  Log.e(TAG, "onNext : isDisposable切断 : " + mDisposable.isDisposed() + "\n");
              }
          }
  
          @Override
          public void onError(@NonNull Throwable e) {
              Log.e(TAG, "调用onError : value : " + e.getMessage() + "\n" );
          }
  
          @Override
          public void onComplete() {
              Log.e(TAG, "调用onComplete" + "\n" );
          }
      });
  

  创建
  Observable 时，回调的是 ObservableEmitter ，并且直接 throws Exception。其次，在创建的
  Observer 中，也多了一个回调方法：onSubscribe，传递参数为Disposable，Disposable 用于解除订阅。

• Just
  在创建后就会发送这些对象，相当于执行了数次onNext()。

  Observable.just("1", "2", "3" , "4")
                  .subscribeOn(Schedulers.io())
                  .observeOn(AndroidSchedulers.mainThread())
                  .subscribe(new Consumer<String>() {
                      @Override
                      public void accept(@NonNull String s) throws Exception {
                          Log.e(TAG,"accept : onNext : " + s + "\n" );
                      }
                  });
  

  
  创建时传入1、2、3、4, 快速创建被观察者对象（Observable）,最多只能发送10个以下事件。

• doOnNext
  让订阅者在接收到数据之前可以自定义一些你想让他做的事情。

   Observable.just(1, 2, 3, 4)
                  .doOnNext(new Consumer<Integer>() {
                      @Override
                      public void accept(@NonNull Integer integer) throws Exception {
                          Log.e(TAG, "doOnNext 哈哈哈"+integer);
                      }
                  }).subscribe(new Consumer<Integer>() {
              @Override
              public void accept(@NonNull Integer integer) throws Exception {
                  Log.e(TAG, "doOnNext 嘿嘿嘿" + integer);
              }
          });
  

  

• map
  作用是对发送的每一个事件应用一个函数，让每一个事件都按照指定的函数去变化

• flatMap与 concatMap
  这两个操作符都可以把Observable 通过某种方法转换为多个 Observables，然后再把这些分散的 Observables装进一个单一的 Observable中。区别在于，flatMap
  并不能保证事件的顺序，而 concatMap 可以。

• distinct
  去重

• Filter
  过滤器，可以接受一个参数，让其过滤掉不符合我们条件的值。

• from
  将传入的数组或 Iterable 拆分成具体对象后，依次发送出来。

参考文档1
参考文档2