RxJava使用场景整理_rxjava操作符使用场景-CSDN博客

本文链接：https://blog.csdn.net/apple_51426592/article/details/126470006

Rxjava是什么（异步库、响应式编程）

基于自己的理解简单的下一个定义： RxJava是一个使用Java语言实现基于观察者模式拓展而来的高效异步库。

1.缓存的逻辑处理

取数据时先检查是否有内存缓存，然后再检查是否有文件缓存，再从网络上请求数据，任何一个条件满足则不执行后面的操作，如我们平时去请求图片的逻辑。

Observable<String> memory = Observable.create(new Observable.OnSubscribe<String>() {
    @Override
    public void call(Subscriber<? super String> subscriber) {
        if (memoryCache != null) {
            subscriber.onNext(memoryCache);
        } else {
            subscriber.onCompleted();
        }
    }
});
Observable<String> disk = Observable.create(new Observable.OnSubscribe<String>() {
    @Override
    public void call(Subscriber<? super String> subscriber) {
        String cachePref = rxPreferences.getString("cache").get();
        if (!TextUtils.isEmpty(cachePref)) {
            subscriber.onNext(cachePref);
        } else {
            subscriber.onCompleted();
        }
    }
});

Observable<String> network = Observable.just("network");

//依次检查memory、disk、network
Observable.concat(memory, disk, network)
.first()
.subscribeOn(Schedulers.newThread())
.subscribe(s -> {
    memoryCache = "memory";
    System.out.println("--------------subscribe: " + s);
});

2.使用merge合并两个数据源

例如一组数据来自网络，一组数据来自文件，需要合并两组数据一起展示

Observable.merge(getDataFromFile(), getDataFromNet())
              .observeOn(AndroidSchedulers.mainThread())
              .subscribe(new Subscriber<String>() {
                  @Override
                  public void onCompleted() {
                      log.d("done loading all data");
                  }

                  @Override
                  public void onError(Throwable e) {
                      log.d("error");
                  }

                  @Override
                  public void onNext(String data) {
                      log.d("all merged data will pass here one by one!")
              });

3.一个API的请求依赖另一个接口返回的数据（解决嵌套回调的问题）

例如要登录获取到token后再去获取用户详情

NetworkService.getToken("username", "password")
    .flatMap(s -> NetworkService.getUserInfo(s))
    .subscribe(s -> {
        System.out.println("message: " + s);
    });

4.每个HTTP请求都带token给服务器 [如果token过期则获取新token]

一般请情况下,很多公司的提api接口, 请求的的时候都需要带有token, 该token在用户第一次启动app或者登陆的时候去获取. 以后的所有请求都需要带该Token
如果token过期, 服务器将返回401, 这时候就需要去请求获取token的接口, 如果获取成功接着在请求原来的接口.
这个时候就两个回调的嵌套了. 实现起来比较费劲, 而且也不够优雅. 代码的可维护性变得很差.
可以使用 onErrorResumeNext 来处理这样的业务逻辑.

5. HTTP 请求重试

当请求网络的时候出现错误, 我们需要重试, 如果不停的重试也没有多大意义, 出现错误延迟多少秒然后重试.
所以使用RxJava可以设置最多重试次数和延迟的时间

6.使用throttleFirst防止按钮重复点击（点击防抖）

debounce也能达到同样的效果

RxView.clicks(button)
              .throttleFirst(1, TimeUnit.SECONDS)
              .subscribe(new Observer<Object>() {
                  @Override
                  public void onCompleted() {
                        log.d ("completed");
                  }

                  @Override
                  public void onError(Throwable e) {
                        log.e("error");
                  }

                  @Override
                  public void onNext(Object o) {
                       log.d("button clicked");
                  }
              });

7.搜索防抖

现在几乎所有的App都有搜索功能 , 一般情况我们监听EditText控件,当值发生改变去请求搜索接口. 这将导致2个问题:

可能导致很多没有意义的请求,耗费用户流量(因为控件的值没更改一次立即就会去请求网络)

可能导致最终的结果不是用户想要的. 例如,用户一开始输入关键字’AB’ 这个时候出现两个请求, 一个请求是A关键字, 一个请求是AB关键字.
表面上是’A’请求先发出去, ‘AB’请求后发出去. 如果后发出去的’AB’请求先返回, ‘A’请求后返回,那么’A’请求后的结果将会覆盖’AB’请求的结果.
从而导致搜索结果不正确.

很多文章说使用 debounce 操作可以解决这个问题.
但是, RxJava也不能完全解决这个问题, 可以使用 debounce 操作符也只能从一定程度上减少这种情况的出现.
比如: 一开始用户输入了AB两个字符, 在某个时间段内, 用户没有输入新的关键字, 将会发出搜索请求, 此时用户又输入新的关键字C,
那就输入框就是ABC了, 在某个时间段内, 用户没有输入新的关键字, 将会发出搜索新的请求. 如果’ABC’的请求返回比’AB’的快, 那么AB请求的结果将会覆盖’ABC’请求的结果,从而导致不正确的结果

RxTextView.textChangeEvents(inputEditText)
      .debounce(400, TimeUnit.MILLISECONDS) 
      .observeOn(AndroidSchedulers.mainThread())
      .subscribe(new Observer<TextViewTextChangeEvent>() {
    @Override
    public void onCompleted() {
        log.d("onComplete");
    }

    @Override
    public void onError(Throwable e) {
        log.d("Error");
    }

    @Override
    public void onNext(TextViewTextChangeEvent onTextChangeEvent) {
        log.d(format("Searching for %s", onTextChangeEvent.text().toString()));
    }
});

8.RxJava代替EventBus广播效果

注意：RxBus并不是一个库，而是一种模式，是使用了RxJava的思想来达到EventBus的广播效果。

9.使用combineLatest合并最近N个结点

例如：注册的时候所有输入信息（邮箱、密码、电话号码等）合法才点亮注册按钮。

Observable<CharSequence> _emailChangeObservable = RxTextView.textChanges(_email).skip(1);
Observable<CharSequence> _passwordChangeObservable = RxTextView.textChanges(_password).skip(1);
Observable<CharSequence>   _numberChangeObservable = RxTextView.textChanges(_number).skip(1);

Observable.combineLatest(_emailChangeObservable,
              _passwordChangeObservable,
              _numberChangeObservable,
              new Func3<CharSequence, CharSequence, CharSequence, Boolean>() {
                  @Override
                  public Boolean call(CharSequence newEmail,
                                      CharSequence newPassword,
                                      CharSequence newNumber) {

                      Log.d("xiayong",newEmail+" "+newPassword+" "+newNumber);
                      boolean emailValid = !isEmpty(newEmail) &&
                                           EMAIL_ADDRESS.matcher(newEmail).matches();
                      if (!emailValid) {
                          _email.setError("Invalid Email!");
                      }

                      boolean passValid = !isEmpty(newPassword) && newPassword.length() > 8;
                      if (!passValid) {
                          _password.setError("Invalid Password!");
                      }

                      boolean numValid = !isEmpty(newNumber);
                      if (numValid) {
                          int num = Integer.parseInt(newNumber.toString());
                          numValid = num > 0 && num <= 100;
                      }
                      if (!numValid) {
                          _number.setError("Invalid Number!");
                      }

                      return emailValid && passValid && numValid;

                  }
              })//
              .subscribe(new Observer<Boolean>() {
                  @Override
                  public void onCompleted() {
                      log.d("completed");
                  }

                  @Override
                  public void onError(Throwable e) {
                     log.d("Error");
                  }

                  @Override
                  public void onNext(Boolean formValid) {
                     _btnValidIndicator.setEnabled(formValid);  
                  }
              });

10.使用timer做定时操作。当有“x秒后执行y操作”类似的需求的时候，想到使用timer

例如：2秒后输出日志“hello world”，然后结束。

Observable.timer(2, TimeUnit.SECONDS)
              .subscribe(new Observer<Long>() {
                  @Override
                  public void onCompleted() {
                      log.d ("completed");
                  }

                  @Override
                  public void onError(Throwable e) {
                      log.e("error");
                  }

                  @Override
                  public void onNext(Long number) {
                      log.d ("hello world");
                  }
              });

11.使用interval做周期性操作。当有“每隔xx秒后执行yy操作”类似的需求的时候，想到使用interval

例如：每隔2秒输出日志“helloworld”。

     Observable.interval(2, TimeUnit.SECONDS)
              .subscribe(new Observer<Long>() {
                  @Override
                  public void onCompleted() {
                     log.d ("completed");
                  }

                  @Override
                  public void onError(Throwable e) {
                     log.e("error");
                  }

                  @Override
                  public void onNext(Long number) {
                     log.d ("hello world");
                  }
              });

12.使用schedulePeriodically做轮询请求

Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(final Subscriber<? super String> observer) {

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

13.RxJava进行数组、list的遍历，做一些数据变换

Observable.just("1", "2", "2", "3", "4", "5")
    .map(Integer::parseInt)
    .filter(s -> s > 1)
    .distinct()
    .take(3)
    .reduce((integer, integer2) -> integer.intValue() + integer2.intValue())
    .subscribe(System.out::println);//9

14.结合RxJava做网络请求框架,链式调用，逻辑清晰，自由切换线程，解决嵌套回调.

15.响应式的界面

SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this);
RxSharedPreferences rxPreferences = RxSharedPreferences.create(preferences);

Preference<Boolean> checked = rxPreferences.getBoolean("checked", true);

CheckBox checkBox = (CheckBox) findViewById(R.id.cb_test);
RxCompoundButton.checkedChanges(checkBox)
        .subscribe(checked.asAction());