Android-RxJava(上)

Rxjava出来已经好久了,但始终存在于会使用的阶段,今天来做个总结。
参考:
https://mp.weixin.qq.com/s/7sKjc5ahHI4fmadXW-uP_w
https://mp.weixin.qq.com/s/RkGHpVSpngfHDXo4Es-a9w
https://mp.weixin.qq.com/s/elA3Gib57YGWnXOEcFOPUQ
https://mp.weixin.qq.com/s/WaWEtFjmajalISwAkJyuKw

1.简介

RxJava是观察者模式的扩展,是响应式函数的扩展库,在观察者模式上实现了发送者(observable)和接受者(observer)解耦;链式调用降低业务之间的依赖,使得代码很简介;支持泛型,减少冗余代码,增强代码可读性;支持设置同步异步切换,简单实现异步回调;观察者与被观察者的继承,多态,更好解决复杂逻辑的嵌套。

2.基本使用

2.1

首先RxJava一般有三要素

  • 观察者(Observer)
  • 被观察者(Observable)
  • 订阅,即绑定(subscribe)
    话不多说上代码:
    首先添加相关依赖
    //RxJava的相关依赖
    implementation 'io.reactivex.rxjava2:rxjava:2.1.4'
    implementation 'io.reactivex.rxjava2:rxandroid:2.0.2'

注意:RxAndroid是RxJava的一个针对Android平台的扩展,主要用于 Android 开发。

/**
     * 执行RxJava相关代码
     */
    private void doRxJava() {

        //创建被观察者
        Observable observable =Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter emitter) throws Exception {
               //通过ObservableEmitter发射器发送事件
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
                emitter.onComplete();
            }

        });

        //创建观察者
        Observer observer = new Observer() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.e(TAG, "======================onSubscribe");
            }
            @Override
            public void onNext(Integer integer) {
                Log.e(TAG, "======================onNext " + integer);
            }
            @Override
            public void onError(Throwable e) {
                Log.e(TAG, "======================onError");
            }
            @Override
            public void onComplete() {
                Log.e(TAG, "======================onComplete");
            }
        };
        
        //被观察者通过subscribe()与观察者建立关系
        observable.subscribe(observer);
    }

打印信息如下:


Android-RxJava(上)_第1张图片
image.png

通过打印信息可以看到:
在被观察者通过订阅绑定观察者之后,他们先后执行了观察者的onSubscribe()->被观察者的subscribe(),然后是观察者的onNext() -> onComplete().当然onError()方法没有执行,因为我们的请求时成功的,那么这些方法都有什么含义呢:

  • onSubscribe() ,观察者的方法,如果我们的被观察者通过subscribe订阅观察者成功则会执行该方法。
  • subscribe() ,被观察者的方法,通过该方法在订阅成功后给观察者发送事件
  • onNext(),观察者的方法,接受被观察者事件处理结果的方法。
  • onComplete(),观察者的方法,事件完成调用的方法。
  • onError(),观察者的方法,事件因为异常所调用的方法,注意该方法执行后其他事件将不会继续发送,如onComplete()

当然也可以换一种写法,通过链式调用的方式,如下:

 /**
     * 执行RxJava相关代码
     */
    private void doRxJava2() {

        Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
                emitter.onComplete();
            }

        }).subscribe(new Observer() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.e(TAG, "======================onSubscribe");
            }

            @Override
            public void onNext(Integer integer) {
                Log.e(TAG, "======================onNext " + integer);
            }

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

            @Override
            public void onComplete() {
                Log.e(TAG, "======================onComplete");
            }
        });
    }

总结:
被观察者(Observable):通过订阅行为(subscribe())把事件按顺序发送到 观察者(Observer)。 观察者(Observer):按顺序接收到事件&做出响应反馈。

2.2

你可能看到过这种写法:

      Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter emitter) throws Exception {
                emitter.onNext(1)
            }

        })..subscribe(
                new Action1() {
                    @Override
                    public void call(String s) {
                        System.out.println(s);
                    }
                }
        );

这是RxJava的时候的写法,我们说说Action1或者Action是什么意思呢,为什么不用new Observer了呢?
如果我们到的Observer不想实现 OnComplete ()和 OnError()方法,只需要在 onNext 时做一些处理,可以用 Action1 或Action类,明白了吧。
subscribe 方法有一个重载版本,接受1~3个 Action1 类型的参数,分别对应 OnNext,OnError,OnComplete然后我们现在只需要 onNext,就只需要传入一个参数。
同样的我们来看看如果你升级到RxJava2,改如果写呢?

//创建被观察者
        Observable observable = Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter emitter) throws Exception {
                Log.e(TAG, "======================" + Thread.currentThread().getName());
                //通过ObservableEmitter发射器发送事件
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);

                emitter.onComplete();
            }

        });
       //好比onNext
        Consumer onNextConsumer = new Consumer() {
            @Override
            public void accept(Integer integer) {
                Log.e(TAG, "======================onNext " + integer);
            }
        };
        //好比onError
        Consumer onErroyCusumer = new Consumer() {
            @Override
            public void accept(Integer integer) {
                Log.e(TAG, "======================onError");
            }
        };
        //好比onComplete
        Action completeAction = new Action() {
            @Override
            public void run() throws Exception {
                Log.e(TAG, "======================onComplete");
            }
        };

        //被观察者通过subscribe()订阅观察者
        observable.subscribe(onNextConsumer, onErroyCusumer, completeAction);

RxJava和RxJava2关于Acton的的最大区别是:Action -> Consumer
这就是RxJava2的写法,同志们需要了解一下RxJava和RxJava2升级的区别,网上有很多,就不推荐了。

3.操作符

RxJava操作符是RxJava中重要的部分 ,操作符实质上就是RxJava函数式编程模式的体现,而操作符的种类包括创建操作符,变换操作符,合拼操作符,过滤操作符,条件操作符,其他操作符,今天我们来逐一讲解:

3.1创建操作符

含义:被观察者把事件发送至观察者。
具体应用:

应用种类
数据遍历 just() fromArray() fromlterable() range()
定时任务 interval() intervalRange()
异步嵌套回调 create()
延迟任务 defer() time()

这么多,我们每个类别说一个就好了,其余自行百度。

  • just()的使用
    just 只用于处理单个的数据。
 Observable.just("123456789").subscribe(new Consumer() {
            @Override
            public void accept(String s) throws Exception {
                Log.e(TAG, "======================accept"+s);
            }
        });

这里不得不提一下fromArray(),from和fromArray的区别是:fromArray用于转换多个数据,比如 ArrayList等包含多个数据的数组或者列表,可以传入多于10个的变量,并且可以传入一个数组;,而 just 只用于处理单个的数据。
代码:

 List list = Arrays.asList(
                "1", "2", "3", "4", "5", "6"
        );
        Observable.fromArray(list).subscribe(new Consumer>() {
            @Override
            public void accept(List strings) throws Exception {
                Log.e(TAG, "======================accept"+strings);
            }
        });

打印结果:


image.png

还忍不住想说一下fromlterable(),fromlterable和fromArray的区别是fromIterable发送一个 List 集合数据给观察者,并依此打印集合中的元素。

  • interval()
    interval 操作符用于间隔时间执行某个操作,其接受三个参数,分别是第一次发送延迟,间隔时间,时间单位.
Observable.interval(3,2, TimeUnit.SECONDS).subscribe(new Consumer() {
            @Override
            public void accept(Long aLong) throws Exception {
                Log.e(TAG, "======================accept"+aLong);
            }
        });

结果:


Android-RxJava(上)_第2张图片
image.png

intervalRange()可以指定发送事件的开始值和数量,其他与 interval() 的功能一样。

  • create() 就不用说了吧。
  • defer()
    defer操作符就相当于懒加载,只有等observable 与observer建立了订阅关系时,observable才会建立执行相关代码。
int num = 0;
    /**
     * 创建操作符Defer
     */
    private void rxJavaDefer(){
        num=1;
        Observable observable = Observable.defer(new Callable>() {
            @Override
            public ObservableSource call() throws Exception {
                return Observable.just(num);
            }
        });
        num = 2;
        Consumer consumer =new Consumer() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e(TAG, "================onNext " + integer);
            }
        };
        observable.subscribe(consumer);
    }

结果:



获取的是最后赋值的 num = 2;也就是Observable.defer()并没有在创建的时候执行。如果这么说还不明白,我们看一下直接用just操作符执行的结果

int a = 0;
    private void rxJavaDefer(){
        a =1;
        Observable observable = Observable.just(a);
        a = 2;
        Consumer consumer =new Consumer() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e(TAG, "================onNext " + integer);
            }
        };
        observable.subscribe(consumer);
    }

结果打印:


image.png

这下明白了吧!

3.2变换操作符

含义:被观察者把序列事件加工为其他序列事件(变换)。

应用种类
变换 map() flatmap()/concatmap()
  • map()
    map 可以将被观察者发送的数据类型转变成其他的类型.
    以下代码我们将Integer转为String
Observable.just(1,2,3).map(new Function() {
         @Override
         public String apply(Integer integer) throws Exception {
             return integer+"";
         }
     }).subscribe(new Consumer() {
         @Override
         public void accept(String s) throws Exception {
             Log.e(TAG, "accept:Integer转化为String后的数据"+s );
         }
     });

结果:


image.png
  • concatmap
    concatmap和flatmap操作符区别在于concatmap是有序发送而flatmap是无序的。
    比如我们要制定一任务,打印每人上午和下午的工作安排,先创建相关实体类:
private class User{
        //姓名
        String name;
        //任务列表
        List listPlan;

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public List getListPlan() {
            return listPlan;
        }

        public void setListPlan(List listPlan) {
            this.listPlan = listPlan;
        }
    }
   //详细计划实体类
    public class Plan{
        //姓名
        String name;
        //时间
        String time;
        //工作内容
        String content;

        public String getTime() {
            return time;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public void setTime(String time) {
            this.time = time;
        }

        public String getContent() {
            return content;
        }

        public void setContent(String content) {
            this.content = content;
        }

        public Plan(String name ,String time, String content) {
            this.time = time;
            this.content = content;
            this.name=name;
        }
    }

执行代码:

  /**
     * concatMap,有序将事件序列中的元素进行整合加工,返回一个新的被观察者,对应flatMap是无序的
     */
    private  void rxJavaconcatMap(){
        LinkedList zhangsan =new LinkedList<>();
        Plan plan =new Plan("张三","上午","打扫卫生");
        Plan plan2 =new Plan("张三","下午","学习");
        zhangsan.add(plan);
        zhangsan.add(plan2);


        LinkedList lisi =new LinkedList<>();
        Plan plan3 =new Plan("李四","上午","打扫卫生");
        Plan plan4 =new Plan("李四","下午","参加体育活动");
        lisi.add(plan3);
        lisi.add(plan4);

        User user =new User();
        User user2 =new User();

        user.setName("张三");
        user.setListPlan(zhangsan);

        user2.setName("李四");
        user2.setListPlan(lisi);

        List link =new LinkedList<>();
        link.add(user);
        link.add(user2);

        //我们上有提到fromIterable操作符是将集合中的元素输出
        Observable.fromIterable(link).concatMap(new Function>(){

            @Override
            public Observable apply(User user) throws Exception {
                //注意这里是返回一个新的被观察者
                return Observable.fromIterable(user.getListPlan());
            }
        }).subscribe(new Consumer() {
            @Override
            public void accept(Plan plan) throws Exception {
                Log.e(TAG, "accept() returned: " +plan.getName()+plan.getTime()+""+plan.getContent() );
            }
        });

    }

结果:


Android-RxJava(上)_第3张图片
image.png

3.3组合操作符

含义:将多个被观察组合 & 将它们需要发送的事件合拼。

应用种类
组合多个被观察者,合并事件 concatArray()(发送事件--串行) concatDelayError() mergeArray()(发送事件--并发) mergeArrayDelayError()
组合多个被观察者,组合为一个被观察者 zip() combinelatest()
发送事件前追加其他事件 startWithArray() startWith()
组合多个事件为一个事件 reduce collect()
汇总发送事件数量 count()
  • concatArray()
    concatArray可以将多个观察者组合在一起,然后按照之前发送顺序发送事件。需要注意的是,concat() 最多只可以发送4个事件,而concatArray()可以发送多个。
    代码:
 Observable.concatArray(Observable.just(1,2),
                Observable.just(3,4),
                Observable.just(5,6),
                Observable.just(7,8),
                Observable.just(9,10)).subscribe(new Consumer() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e(TAG, "accept: "+integer);
            }
        });

结果:


Android-RxJava(上)_第4张图片
image.png

而mergeArray则和concatArray相反这里就不说了。

  • zip()
    zip会将多个被观察者合并,根据各个被观察者发送事件的顺序一个个结合起来,最终发送的事件数量会与源 Observable 中最少事件的数量一样。
/**
     * 组合操作符zip()
     */
    private void rxJavaZip() {
        //intervalRange()参数依此是:从那个数开始,发送次数,首次延迟,发送间隔
        Observable.zip(Observable.intervalRange(1, 3, 2, 1, TimeUnit.SECONDS)
                        .map(new Function() {
                            @Override
                            public String apply(Long aLong) throws Exception {
                                String s = "A" + aLong;
                                Log.e(TAG, "===================A 发送的事件 " + s);
                                return s;
                            }
                        }),
                Observable.intervalRange(1, 4, 2, 1, TimeUnit.SECONDS)
                        .map(new Function() {
                            @Override
                            public String apply(Long aLong) throws Exception {
                                String s2 = "B" + aLong;
                                Log.e(TAG, "===================B 发送的事件 " + s2);
                                return s2;
                            }
                        }),
                new BiFunction() {
                    @Override
                    public String apply(String s, String s2) throws Exception {
                        String res = s + s2;
                        return res;
                    }
                }).subscribe(new Consumer() {
            @Override
            public void accept(String s) throws Exception {
                Log.e(TAG, "===================组合A和B发送的事件 " + s);
            }
        });
    }

打印结果:


Android-RxJava(上)_第5张图片
image.png

上面代码中有两个 Observable,第一个发送事件的数量为3个,第二个发送事件的数量为4个,可以发现最终接收到的事件数量是3,那么为什么第二个 Observable 没有发送第4个事件呢?因为在这之前第一个 Observable 已经发送了 onComplete 事件,所以第二个 Observable 不会再发送事件。

-startWithArray & startWith
在发送事件之前追加事件,startWith() 追加一个事件,startWithArray() 可以追加多个事件。追加的事件会先发出。

 Observable.just(5, 6, 7)
                .startWithArray(2, 3, 4)
                .startWith(1)
                .subscribe(new Consumer < Integer > () {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.e(TAG, "================accept " + integer);
                    }
                });

打印:


Android-RxJava(上)_第6张图片
image.png
  • reduce()
    reduce,作用是将发送数据以一定逻辑聚合起来.
/**
     * 组合操作符reduce
     */
    private void reduce(){
        Observable.just(0, 1, 2)
                .reduce(new BiFunction < Integer, Integer, Integer > () {
                    @Override
                    public Integer apply(Integer integer, Integer integer2) throws Exception {
                        int resullt = integer + integer2;
                        Log.e(TAG, "====================integer " + integer);
                        Log.e(TAG, "====================integer2 " + integer2);
                        Log.e(TAG, "====================resullt " + resullt);
                        return resullt;
                    }
                })
                .subscribe(new Consumer < Integer > () {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.e(TAG, "==================accept " + integer);
                    }
                });
    }

打印:


Android-RxJava(上)_第7张图片
image.png

看到没得,其实就是前2个数据聚合之后,然后再与后1个数据进行聚合,一直到没有数据为止。

  • count()
    count,返回被观察者发送事件的数量。
  /**
     * 组合操作符count
     */
    private void count (){
        Observable.just(1, 2, 3,4,5)
                .count()
                .subscribe(new Consumer < Long > () {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        Log.e(TAG, "accept: "+aLong );
                    }
                });
    }

结果打印


先整这么多吧,剩下的下一篇内容再说。

你可能感兴趣的:(Android-RxJava(上))