Rxjava && RxAndroid的基础使用

最新推荐文章于 2024-08-09 07:11:04 发布

魏华达

最新推荐文章于 2024-08-09 07:11:04 发布

阅读量905

点赞数

分类专栏： Android

本文链接：https://blog.csdn.net/a820703048/article/details/105472595

版权

Android 专栏收录该内容

49 篇文章 0 订阅

订阅专栏

1.背景

Rxjava是微软公司为了解决实际遇到的流问题而发明出来的，它又很多优点比如

jar包非常小只有大概一m
是一个轻量级的框架
支持java 8 lamba表达式
从Android2.3开始支持
支持同步和异步
RxAndroid是Rxjava 提供给Android的一个扩展库，它主要是提供了一个调度器Schedulers，可以解决子线程和主线程切换的问题。

2.观察者模式

需要知道的几个对象
Observable 被观察者
Observer 观察者
subscribe 订阅
观察者要订阅被观察者
被观察者通过执行一系列操作然后通过onNext告知观察者然后观察者做出某种操作例如更新UI

3.举个栗子

先gradle 加远程依赖

    //RxJava的依赖包（我使用的最新版本）
    compile 'io.reactivex.rxjava2:rxjava:2.0.1'
    //RxAndroid的依赖包
    compile 'io.reactivex.rxjava2:rxandroid:2.0.1'

最简单的写法

   //第一步创建被观察者
        Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("hell wold");
                emitter.onComplete();
            }
        });

        //观察者
        Observer observer= new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                //用于取消订阅
            }

            @Override
            public void onNext(String s) {
            //下一个
            }

            @Override
            public void onError(Throwable e) {
                //错误回调
            }

            @Override
            public void onComplete() {
                //总结
            }
        };
        //被观察者 订阅观察者
        observable.subscribe(observer);



//或者连起来
 Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("hell wold");
                emitter.onComplete();
            }
        }).subscribe(new Observer<String>() {
          @Override
          public void onSubscribe(Disposable d) {
              
          }

          @Override
          public void onNext(String s) {

          }

          @Override
          public void onError(Throwable e) {

          }

          @Override
          public void onComplete() {

          }
      });

4 Rxjava常用操作符

4.1Rxjava创建型操作符

1 create ：最原始的创建操作符

 Observable.create((ObservableOnSubscribe<String>)
            emitter -> {
              })

2 just :简化了创建的意思常用在直接给出结果的

  Observable.just(Boolean boolean).subscribe(aBoolean -> { });

3.from 主要是给出一串数组，主要是进行流传递,例如下面会进行按顺序传递

    Observable.just(new Integer[]{1,2}).subscribe(aBoolean -> { });

4.interval 主要是设置每间隔的时间去做某些事情

    Observable.interval(200, TimeUnit.SECONDS).subscribe(aLong -> { });

5 range 从某个范围开始输出多少个

    Observable.range(200, 5).subscribe(aLong -> { });

6.repeat 是为了重复多少次

  Observable.range(1,5).repeat(2).subscribe(integer -> { });

7.time 定时器，经常可以用于延时之类的

 Observable.timer(2, TimeUnit.SECONDS).repeat(200).subscribe(aLong -> {});

4.2 transfrom 转换符

1.map 其实就是将被观察者的数据转成观察者的想要的数据

  Observable.just(123).map(new Function<Integer, String>() {
            @Override
            public String apply(Integer integer) throws Exception {
                return integer+"hello word";
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {

            }
        });

2.flatmap 这个其实是1对多将过来的数据通过再处理返回一个Observable 给到终的observe

   Observable.just(1,2,3).flatMap(new Function<Integer, ObservableSource<?>>() {
            @Override
            public ObservableSource<?> apply(Integer integer) throws Exception {
                return Observable.just(true);
            }
        }).subscribe(new Consumer<Object>() {
            @Override
            public void accept(Object o) throws Exception {

            }
        });

其他用得很少就不介绍了

4.2 Filter 转换符

1.distinct 去重复操作符比如下面会去掉3

  Observable.just(1,2,3,3).distinct().subscribe(o -> {  });

2.elementAt 取列表指定位置去弹射

 Observable.just(1,2,3,3).elementAt(3).subscribe(o -> {    });

filter :自定义过滤器比如要数大于2

        Observable.just(4, 2, 3).filter((Predicate<? super Integer>) integer -> integer > 2).subscribe(o -> {})

firstElement 获取第一个数值

   Observable.just(4, 2, 3).firstElement().subscribe(integer -> {
            
        });

5.ignoreElements 忽略所有发射的值
6. last 取最后一个发射值
7. simpe 采样数据例如每个5秒获取一次数据前提是数据一直在发射
8. skip 跳过某些项比如跳过前面两项
9. take 取前面两个 take 2

4.3 合并操作符

zip 将两个Observable 发射出来的进行组合，但是如果有一个Observable没有数据了会抛出异常下面就会打印出 5，7，9

  Observable<Integer> observable1 = Observable.just(1, 2, 3);
        Observable<Integer> observable2 = Observable.just(4, 5, 6);
        Observable.zip(observable1, observable2, new BiFunction<Integer, Integer, Object>() {

            @Override
            public Object apply(Integer integer1, Integer integer2) throws Exception {
                return integer1+integer2;
            }
        }).subscribe(new Consumer<Object>() {
            @Override
            public void accept(Object o) throws Exception {

            }
        });

merge 将数据进行顺序排列输出下面就会输出 1，2，3，4，5，6

  Observable<Integer> observable1 = Observable.just(1, 2, 3);
        Observable<Integer> observable2 = Observable.just(4, 5, 6);
        Observable.merge(observable1,observable2).subscribe(integer -> {
            
        });

startWith 将数据进行顺序排列输出下面就会输出 4,5,6,1,2,3

 Observable<Integer> observable1 = Observable.just(1, 2, 3);
        Observable<Integer> observable2 = Observable.just(4, 5, 6);

        observable1.startWith(observable2).subscribe(integer -> {
            
        });

3.combineLatest 可以让数据源的数据自由组合，让自己自由定制

 Observable<Integer> observable1 = Observable.just(1, 2, 3);
        Observable<Integer> observable2 = Observable.just(4, 5, 6);

 Observable.combineLatest(observable1, observable2, new BiFunction<Integer, Integer, Object>() {
           @Override
           public Object apply(Integer integer, Integer integer2) throws Exception {
               return null;
           }
       }).subscribe(new Consumer<Object>() {
           @Override
           public void accept(Object o) throws Exception {

           }
       });

5. Schedulers 调度器

Schedulers.io()
Schedulers.computation()
Schedulers.immediate()
Schedulers.newThead();
AndroidSchedulers.mainThread()

这样子就可以很方便的实现子线程和主线程的切换，一般请求网络在子线程，更新ui在主线程中，在被观察者中观察耗时操作，在观察者中进行主线程切换。

   Observable.create(emitter -> {

        }).subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(o -> {
                 }, throwable -> {
                   });