最全的RxJava使用场景小结

最新推荐文章于 2024-09-11 01:13:07 发布
最新推荐文章于 2024-09-11 01:13:07 发布
阅读量257 收藏
点赞数
分类专栏： Android 文章标签： RxJava RxAndroid

 

一、Scheduler线程切换

这种场景经常会在“后台线程取数据，主线程展示”的模式中看见


Observable.just(1, 2, 3, 4)
            .subscribeOn(Schedulers.io()) // 指定 subscribe() 发生在 IO 线程
            .observeOn(AndroidSchedulers.mainThread()) // 指定 Subscriber 的回调发生在主线程
            .subscribe(new Action1<Integer>() {
        @Override
        public void call(Integer number) {
            Log.d(tag, "number:" + number);
        }
    });

二、使用debounce做textSearch

用简单的话讲就是当N个结点发生的时间太靠近（即发生的时间差小于设定的值T），debounce就会自动过滤掉前N-1个结点。

比如在做百度地址联想的时候，可以使用debounce减少频繁的网络请求。避免每输入（删除）一个字就做一次联想

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()));
    }
});

三、Retrofit结合RxJava做网络请求框架
这里不作详解，具体的介绍可以看扔物线的这篇文章，对RxJava的入门者有很大的启发。其中也讲到了RxJava和Retrofit如何结合来实现更简洁的代码

四、RxJava代替EventBus进行数据传递：RxBus
注意：RxBus并不是一个库，而是一种模式，是使用了RxJava的思想来达到EventBus的数据传递效果。这篇文章把RxBus讲的比较详细。

五、使用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);  
                  }
              });


六、使用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!")
              });

七、使用concat和first做缓存

  依次检查memory、disk和network中是否存在数据，任何一步一旦发现数据后面的操作都不执行。

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);
});
八、使用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");
                  }
              });

九、使用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");
                  }
              });


十、使用throttleFirst防止按钮重复点击

ps：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");
                  }
              });


十一、使用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….”));
            }
        })


十二、RxJava进行数组、list的遍历

        String[] names = {"Tom", "Lily", "Alisa", "Sheldon", "Bill"};
        Observable
                .from(names)
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String name) {
                        log.d(name);
                    }
                });
 

十三、解决嵌套回调（callback hell）问题

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

十四、响应式的界面

比如勾选了某个checkbox，自动更新对应的preference

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());
--------------------- 
作者：THEONE10211024 
来源：CSDN 
原文：https://blog.csdn.net/theone10211024/article/details/50435325 
版权声明：本文为博主原创文章，转载请附上博文链接！

kuangren987
关注
专栏目录
RxJava中多种场景的实现总结
09-01
在本文中，我们将深入探讨RxJava中几种关键的使用场景，包括推迟执行动作、推迟发送执行的结果以及在指定线程中执行操作。RxJava是一个强大的响应式编程库，它允许开发者通过观察者模式来处理异步事件和数据流。下面...
RxJava使用场景总结
布道
04-04 845
RxJava早已经成为java圈最近3年来最流行的类库，无数优秀的开源框架中对其进行接入。但什么场景下使用，其实没有定论，以下是个人整理总结的。 1. 代码迷之缩进 代码中存在大量的缩进，对其可读性非常差，而RxJava提供了非常多的函数足以胜任你98%的需求。 //这么多缩进，难受不 public void getPng() { for (File folder : folder...
从根上理解RXJava，深入RxJava 的适用场景和使用方式（Retrofit、RxBinding、RxBus）
2401_84149368的博客
04-12 264
这个我就做不到一个词说明了……因为这一节的主要内容就是一步步地说明 RxJava 到底怎样做到了异步，怎样做到了简洁。首先是感觉自己的基础还是不够吧，大厂好像都喜欢问这些底层原理。之前的准备只涉及了Java、Android、计网、数据结构与算法这些方面，面对面试官对其他基础课程的考察显得捉襟见肘。下一步还是要查漏补缺，进行针对性复习。最后的最后，那套资料这次一定要全部看完，是真的太全面了，各个知识点都涵盖了，几乎我面试遇到的所有问题的知识点这里面都有！希望大家不要犯和我一样的错误呀！！！一定要看完！
Android Rxjava3 使用场景
最新发布
2401_86964179的博客
09-11 720
特别注意repeatWhen操作符，只有在repeatWhen的Function方法中发射onNext事件，重复(repeat)才能触发，发射onError或者onComplite都会结束重复(repeat)，基于这一点，通过flatMap操作符将事件转化为延迟一定时间的onNext事件，就达到了延时轮询的目的。场景二：轮询固定的次数（间隔一定的时间），可以提前退出轮询，也可以等轮询到指定次数后自动退出，这里的轮询不关心上次请求的结果。场景三：不限次数轮询（间隔一定的时间），不关心上次请求的结果。
Rxjava原理与场景全面解析篇，值得一看！
2401_84121846的博客
04-11 888
这个我就做不到一个词说明了……因为这一节的主要内容就是一步步地说明 RxJava 到底怎样做到了异步，怎样做到了简洁。
RxJava2配置及使用详解
08-30
RxJava2 配置及使用详解 RxJava2 是一个功能强大且流行的响应式编程库，用于处理异步数据流。它基于观察者模式，实现了事件的异步处理。RxJava2 的配置和使用涉及到多个方面，包括 Observable、Observer、Emitter、...
Java扩展库RxJava的基本结构与适用场景小结
09-02
3. **处理事件序列**：在用户交互、系统事件或定时任务等场景下，RxJava可以将事件序列化，通过`debounce`, `throttleFirst`, `buffer`等操作符控制事件的处理节奏，防止过度响应或丢失重要事件。 4. **错误处理**...
RxJavaNotes:RxJava2 应用场景总结及源码学习笔记
04-30
RxJava2 Learning Notes 原理 一系列的事件序列，通过上下游链接，使得上游没产生一个事件，下游就能接收到该事件。 上游和下游就分别对应着RxJava中的Observable和Observer;两者之间的连接就对应着subscribe() 只有...
RxJava使用测试
12-26
**使用场景** 1. **事件监听**：RxJava可以替代传统的Android事件监听器，如OnClickListener，使得事件处理更加简洁和灵活。 2. **网络请求**：在Android应用中，RxJava常与Retrofit结合，用于处理网络请求，提供...
rxjava2中常见的使用场景demo
03-01
demo中有几个常见的Rxjava2中使用的场景，然后使用中有常见的有，在一个界面中有不同的接口请求，可以使用zip控制，使接口中的数据同一时间返回来，但是在zip中 apply（）必须返回一个json，就是不同接口转换成一个json，遇到这个问题时候，可以提取出来json集合，在最后数据回调时再添加进入即可
RxJava使用场景
yzpbright的博客
03-03 657
RxJava学习
RxJava使用场景整理
xiechengfa的技术笔记
11-03 2157
Rxjava是什么（异步库、响应式编程）基于自己的理解简单的下一个定义： RxJava是一个使用Java语言实现基于观察者模式拓展而来的高效异步库。1.缓存的逻辑处理取数据时先检查是否有内存缓存，然后再检查是否有文件缓存，再从网络上请求数据，任何一个条件满足则不执行后面的操作，如我们平时去请求图片的逻辑。Observable<String> memory = Observable.create(ne
Android RxJava使用介绍（一） Hello World
热门推荐
呼啸而过的专栏
05-19 2万+
最近在做东西的时候，一直在使用RxJava框架，越是深入了解RxJava，就越觉得这个框架威力实在是太大了。好东西不能一个人独自享受，后面几篇文章我会由浅入深来介绍一下RxJava的使用方法，相信看完之后，你会跟我一样逐渐喜欢上这个“威力无比”的武器！那么，RxJava到底是什么？使用RxJava到底有什么好处呢？其实RxJava是ReactiveX中使用Java语言实现的版本，目前Reactive
从根上理解RXJava，深入RxJava 的适用场景和使用方式（Retrofit
m0_65146275的博客
12-13 2004
// onNext(“Aloha”); // onCompleted(); from(T[]) / from(Iterable<? extends T>) : 将传入的数组或 Iterable 拆分成具体对象后，依次发送出来。 String[] words = {“Hello”, “Hi”, “Aloha”}; Observable observable = Observable.from(words); // 将会依次调用： // onNe
java 事件监听 多个事件_RxJava实际应用：联合判断多个事件
weixin_42210038的博客
02-24 484
1、需求场景：需要对多个事件进行联合判断如：填写表单时，需要表单里所有信息(姓名、年龄、职业等)都被填写后，才允许点击提交按钮。2、功能说明：表单里所有信息都被填写后，才允许点击提交。3、具体实现：/*步骤2：为每个EditText设置被观察者，用于发送监听事件说明：此处采用了RxBinding：RxTextView.textChanges(name) = 对对控件数据变更进行监听(功能类似Tex...
11章 RxJava、Flow、LiveData适用范围
点击置顶文章查看博客目录（全站式导航）
07-14 1388
LiveData、Kotlin Flow和RxJava三者都属于可观察的数据容器类RxJava是基于观察者模式去实现的响应式编程，可以使用多种操作符进行组合将各种复杂的请求简单化其优点：其缺点：LiveData由Google自2017年推出，LiveData相对RxJava出现较晚，相当于轻量版的RxJava其优点：其缺点：1、LiveData缺少丰富的操作符，为了弥补这个缺点，LiveData提供Transformations工具类中的map，switchMap等操作符 2、LiveData本身的设计理念
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值