rxjava实用示例

每隔两秒执行一次

Observable.interval(2, 2, TimeUnit.SECONDS).subscribe(new Action1() {
        @Override
        public void call(Long aLong) {
            //TODO WHAT YOU WANT
        }
    });

在两秒后去执行一些操作（比如启动页跳转到主页面）

Observable.timer(2, TimeUnit.SECONDS).subscribe(new Action1() {
        @Override
        public void call(Long aLong) {
            //TODO WHAT YOU WANT
        }
    });

模拟发送验证码,count秒钟后可再次点击

Observable.interval(0, 1, TimeUnit.SECONDS)
            .take(count + 1)
            .map(new Function() {
                @Override
                public Long apply(@NonNull Long aLong) throws Exception {
                    return count - aLong;
                }
            })
            .observeOn(AndroidSchedulers.mainThread())
             //订阅时执行
            .doOnSubscribe(new Consumer() {
                @Override
                public void accept(@NonNull Disposable disposable) throws Exception {
                    button.setEnabled(false);
                }
            })
            .subscribe(new Observer() {
                @Override
                public void onSubscribe(Disposable d) {}
                @Override
                public void onNext(Long aLong) {
                    button.setText("剩余" + aLong + "秒");
                }
                @Override
                public void onError(Throwable e) {}
                @Override
                public void onComplete() {
                    //恢复状态
                    button.setEnabled(true);
                    button.setText("发送验证码");
                }
            });

登录框按钮状态判断

    Observable ObservableName = RxTextView.textChanges(mEtPhone);
    Observable ObservablePassword = RxTextView.textChanges(mEtPassword);

    Observable.combineLatest(ObservableName, ObservablePassword, new Func2() {
        @Override
        public Boolean call(CharSequence phone, CharSequence password) {
            return isPhoneValid(phone.toString()) && isPasswordValid(password.toString());
        }
    }).subscribe(new Action1() {
        @Override
        public void call(Boolean aBoolean) {
            RxView.enabled(mBtLogin).call(aBoolean);
        }
    });

缓存策略

    //内存，磁盘，网络有一个有值即返回
    Observable source = Observable
    .concat(memory, disk, network)
    .first(new Func1() {
      @Override public Boolean call(Data data) {
      return data.isUpToDate();
    }
});

合并两个数据源场景

    //合并本地及网络数据，如离线加入购物车等 
    Observable.merge(getLocal(), getNet())  
       .observeOn(AndroidSchedulers.mainThread())  
          .subscribe(new Subscriber() {  
              @Override  
              public void onCompleted() {  
                 Log.d(TAG, "onCompleted: onCompleted");
             }  

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

              @Override  
              public void onNext(String data) {  
                   Log.d(TAG, "onNext: only one ! ");
         });

把多个网络结果合并成一个

Observable combined = Observable.zip(userObservable, eventsObservable, new Func2() {
  @Override
  public UserAndEvents call(JsonObject jsonObject, JsonArray jsonElements) {
    return new UserAndEvents(jsonObject, jsonElements);
  }
});

快速切换线程

Observable.Transformer schedulersTransformer() {
        return new Observable.Transformer() {
            @Override
            public Object call(Object observable) {
                return ((Observable)  observable).subscribeOn(Schedulers.io())
                        .unsubscribeOn(Schedulers.io())
                        .observeOn(AndroidSchedulers.mainThread());
            }
        };
    }
observable.compose (schedulersTransformer()).subscribe(subscriber)
//上面的等价于下面的
observable.subscribeOn(Schedulers.io())
.unsubscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(subscriber);

使用schedulePeriodically做轮询请求

    Observable.create(new Observable.OnSubscribe() {
        @Override
        public void call(final Subscriber observer) {

            Schedulers.newThread().createWorker()
                  .schedulePeriodically(new Action0() {
                      @Override
                      public void call() {
                          observer.onNext(doNetworkCallAndGetStringResult());
                      }
                  }, INITIAL_DELAY, POLLING_INTERVAL, TimeUnit.MILLISECONDS);
        }
    }).subscribe(new Action1() {
        @Override
        public void call(String s) {
            log.d("polling….”));
        }
    })

RxBinding

防止一个按钮重复点击

RxView.clicks(button).debounce(300, TimeUnit.MILLISECONDS).subscribe(new Action1() {
        @Override
        public void call(Void aVoid) {
            Log.i("test", "clicked");
        }
    });
    //throttleFirst与throttleLast/sample不同，在每个采样周期内，它总是发射原始Observable的第一项数据，而不是最近的一项。
    RxView.clicks(button).throttleFirst(300, TimeUnit.SECONDS)
            .subscribe(new Observer