Rxjava2(一)、基础概念及使用

1,303 阅读12分钟

Android进阶系列之第三方库知识点整理。

知识点总结,整理也是学习的过程,如有错误,欢迎批评指出。

写这篇文章的时候,Rxjava3已经出来了,二者差别不是特别大,所以还是基于Rxjava2进行总结,后续会花时间来总结Rxjava3的一些改变。

基础概念

1、什么是Rx

ReactiveX是Reactive Extensions的缩写,一般简写为Rx,最初是LINQ的一个扩展,Rx是由由微软开发并开源的一个编程模型,目标是提供一致的编程接口,帮助开发者更方便的处理异步数据流,Rx库支持很多语言,而 Rxjava 是Rx库基于Java语言提供的函数库。

官网显示支持的语言列表:

官网Rx支持的语言
官网Rx支持的语言

2、观察者模式

观察者模式(Observer),又叫发布-订阅模式(Publish/Subscribe),定义对象间一种一对多的依赖关系,使得每当一个对象改变状态,则所有依赖于它的对象都会得到通知并自动更新,观察者模式属于行为型模式。

我需要打电话跟小明说他被戴绿帽这事,但是我又怕打电话过去他可能在忙,所以我直接给他发信息,让他有时间了再给我回电话,这样,当小明有时间了可能就会给我回电话,他给我回电话,我再含着泪的告诉他要坚强。

在上面这个例子中,小明就是被观察者,我是观察者,我发短信告诉他有时间回我电话这个操作就是订阅,这样我跟他有了依赖关系,当他有时间后,就会回我带电话,我这边响应式的执行后续的操作。

3、响应式(Reactive Programming)编程

一般来说,编程就是为了处理问题,解决问题就可以有不同的视角和思路,其中具有普适性的模式就会归结一种编程思想,我们常说的面向对象,面向过程都是一种编程思想。

响应式编程是一种通过异步和数据流来构建事务关系的编程模式

这里面包含的两个核心概念:

异步:不需要等待处理完成便立刻返回,通过回调将处理结果带回。能提高吞吐量,提高性能和效率。

数据流:就是按照时间线的事件序列,任何东西都可以看做是一个stream。在这个基础上通过函数来过滤(filter)、选择(select)、变换(transform)、结合(combine)这些stream。通过定义事件处理器,来异步捕获感兴趣的stream,即监听(订阅)stream,也叫就是注册观察者。

再对比我们前面的观察者模式看,观察者模式中被观察者观察者之间通过订阅产生依赖,订阅这层关系相当于在二者之前挖了一道水渠,被观察者是上游,观察者是下游,这样被观察者发生改变时候,会将数据流源源不断的发送到产生依赖关系的观察者,通常观察者被观察者是处于同一个线程中,但是响应式编程重点在异步上,即上游和下游可以在不同的线程中工作。

我们可以看一下官网的动图:

4、Rxjava概念及简单使用

Rxjava采用了响应式编程模式,它在观察者模式基础上进行扩展,方便我们的异步操作,观察者被观察者产生订阅关系后,被观察者将数据流发送给观察者的时候,Rxjava提供了丰富的操作符来对数据流进行过滤(filter)、选择(select)、变换(transform)、结合(combine)等等操作,然后再将处理后的数据发送给观察者,又由于其特别棒的链式调用,让逻辑在很复杂的情况下,也能很清晰的通过代码表达出来。

我们先引入rxjava

implementation "io.reactivex.rxjava2:rxjava:2.2.8"
implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'

直接先来一个简单的例子:

  // 通过 Observable 创建一个被观察者
  Observable mObservable = Observable.create(new ObservableOnSubscribe() {
         @Override
         public void subscribe(ObservableEmitter emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
                emitter.onComplete();
            }
        });

        // 通过Observer创建一个观察者
        Observer mObserver = new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                LogUtil.d(TAG + "--onSubscribe");
            }

            @Override
            public void onNext(Integer o) {
                LogUtil.d(TAG + "--onNext  o=" + o);
            }

            @Override
            public void onError(Throwable e) {
                LogUtil.d(TAG + "--onError");
            }

            @Override
            public void onComplete() {
                LogUtil.d(TAG + "--onComplete");
            }
        };
        // 产生订阅关系
        mObservable.subscribe(mObserver);

再看看Rxjava强大的链式调用:

Observable.create(new ObservableOnSubscribe() {
       @Override
       public void subscribe(ObservableEmitter emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
                emitter.onComplete();
            }
            // 这里直接通过subscribe将二者链式调用起来
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                LogUtil.d(TAG + "--Observer--onSubscribe");
            }

            @Override
            public void onNext(Integer o) {
                LogUtil.d(TAG + "--Observer--onNext  o=" + o);
            }

            @Override
            public void onError(Throwable e) {
                LogUtil.d(TAG + "--Observer--onError");
            }

            @Override
            public void onComplete() {
                LogUtil.d(TAG + "--Observer--onComplete");
            }
        });

我们前面说,RxJava是拓展于观察者模式的响应式编程,所以在Rxjava中,就有观察者被观察者以及二者通过订阅产生的依赖关系。

通过上面代码,可以看到:

被观察者 ——————> Observable

观察者 ——————> Observer

订阅关系:Observable ————> subscribe <———— Observer

在上游的 Observable (被观察者)中通过 emitter(发射器)就可以不断地给下游的 Observer (观察者)传送数据流,我们在上游发射了 1、2、3还有发射了一个 onComplete 事件。

我们通过日志可以看到,在下游的 Observer (观察者)成功的接收到了上游发送的数字1、2、3包括通过调用 onComplete()方法来接收上游发送的 onComplete 事件。

通过上面一个简单的例子,我们可以总结出以下几点

4.1、解耦

我们可以看到被观察者和观察者都是独立存在的。

Observable(被观察者):

  // 通过 Observable 创建一个被观察者
  Observable mObservable = Observable.create(new ObservableOnSubscribe() {
         @Override
         public void subscribe(ObservableEmitter emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
                emitter.onComplete();
            }
        });

Observer(观察者):

 // 通过Observer创建一个观察者
        Observer mObserver = new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                LogUtil.d(TAG + "--onSubscribe");
            }

            @Override
            public void onNext(Integer o) {
                LogUtil.d(TAG + "--onNext  o=" + o);
            }

            @Override
            public void onError(Throwable e) {
                LogUtil.d(TAG + "--onError");
            }

            @Override
            public void onComplete() {
                LogUtil.d(TAG + "--onComplete");
            }
        };

可以看到,二者各自独立存在,各干各的事,只是通过 subscribe 来建立依赖关系,这样的话,可以很好地实现代码的复用,比如我们可以创建多个Observer(观察者),和Observable(被观察者)之间通过订阅建立依赖关系后,就能实现Observable(被观察者)发送的数据流被多个Observer(观察者)接收。

4.2、数据流转换(操作符的使用)

第二、Observable(被观察者)通过 emitter(发射器)将数据以流的形式发送给Observer(观察者),前面讲了,既然是以流的形式,那我们是不是可以在观察者接收数据之前,对数据进行处理呢?答案是肯定的,这也是Rxjava的强大之一,它可以通过各种操作符来对数据进行处理,我们先讲一个简单的来。

这里只是简单的演示一些Rxjava对数据流的操作,后面会具体讲操作符,图片中可以看到,我们被观察者明明发射的是一个int型的数值100,但是通过map操作符进行数据流进行转换后,下游的消费者接收到的竟然是String的,这里只是一个小Demo,在Rxjava中,还有各种很强大的操作符来对数据进行各种变态式的处理。

上游被观察者Observable发射数据,下游除了使用Observer来接收数据外,还可以使用消费者Consumer来接收数据,可以看Consumer只有一个accept方法。

先贴一下Rxjava强大的操作符列表,是不是很多?不要被吓到,越多所以我们可以越方便的对数据流进行各种各样的操作,这个后面会单独再讲解。

4.3、线程切换

我们前面说了,Rxjava能更好的异步操作,我们先用上面的例子打印一下他们当前所在的线程情况。

结果:

可以到,统一战线的都在主线程,我们来看看,怎么实现异步。

同样是那个例子,我们添加了下面这两个代码

subscribeOn(Schedulers.io())
observeOn(AndroidSchedulers.mainThread())

subscribeOn : 指定上游执行的线程

observeOn:指定观察者或者消费者执行线程

结果:

代码中,我们指定上游在io线程,而下游在主线程执行,就这么简单的两行代码,就实现了线程切换,实现了异步操作,爽不爽?

当然,我们不光可以指定io线程,Schedulers还提供了其他的线程供我们选择。

我们简单看一个Single线程的源码:

是不是很熟悉?就是通过线程池来创建了一个单线程,其他类似,都是通过线程池来创建,您可以简单去分析一下,当然,如果你对线程池还不熟悉的话,这篇 多线程(三)、线程池 ThreadPoolExecutor 知识点总结 可能适合你看看。

总结

Rxjava的东西还挺多的,这篇先简单的走了一遍Rxjava的基础概念还有简单的使用,关于Rxjava里面还有其他的观察者模式的创建,背压,各种操作符的使用、实战等等骚操作,下篇继续。