【转载】RxJava2.0——从放弃到入门

转自:https://www.jianshu.com/p/cd3557b1a474

RxJava2.0——从放弃到入门

    <!-- 作者区域 -->
    <div class="author">
      <a class="avatar" href="/u/5fd2523645da">
        <img src="//upload.jianshu.io/users/upload_avatars/2477378/2d661a47-cf24-4293-ae3a-4453de1000a9.jpg?imageMogr2/auto-orient/strip|imageView2/1/w/96/h/96" alt="96">


肖邦kaka






6.5


2018.04.02 23:30*
字数 2475
阅读 68757评论 24赞赏 1



    <!-- 文章内容 -->
    <div data-note-content="" class="show-content">
      <div class="show-content-free">
        <h2>前言</h2>

终于到了讲RxJava这一期,RxJava是笔者个人非常喜欢的一个开源库,它很好的将链式编程风格和异步结合在一起。RxJava其实已经推出很久了,可以说是已经很火了,但是目前仍然还有相当一部分Android开发者没有使用过,甚至说是想用,却不知道怎么用,或者不知道自己的项目哪里可以用到,本着让广大开发者理解并且上手项目,从放弃到入门,故推出这边文章。

注:本文所有的具体代码实现都在文章最后的github链接上

学习RxJava2.0之前需不需要学习RxJava1.0

首先,RxJava1.0和RxJava2.0的核心思想都是观察者模式,只不过RxJava2.0在RxJava1.0的基础对一些方法进行了优化,方便于开发者更好地理解其编程思想,同时又增加了一部分新的方法解决1.0存在的问题,例如背压等。所以,如果你学习过RxJava1.0那么很好,你可能已经理解了什么是观察者模式;如果你没有学过RxJava1.0,当然也不必着急,因为本文将从最基本的观察者模式讲起,让你从最基本最简单的角度入手RxJava。综上所述,不管你是不是学过RxJava1.0,都不会影响你学习本篇文章。

观察者模式

在学习RxJava2.0之前,我们必须要弄明白什么是观察者模式。按照我的惯例,先上一个百度百科的权威介绍


百度百科的观察者模式介绍

简单介绍一下,A和B两个,A是被观察者,B是观察者,B对A进行观察,B并不是需要时刻盯着A,而是A如果发生了变化,会主动通知B,B会对应做一些变化。举个例子,假设A是连载小说,B是读者,读者订阅了连载小说,当小说出现了新的连载的时候,会推送给读者。读者不用时刻盯着小说连载,而小说有了新的连载会主动推送给读者。这就是观察者模式。而RxJava正是基于观察者模式开发的。


观察者模式.png

RxJava2.0的基本使用

理解好了观察者模式,我们开始RxJava2.0的学习。首先引入RxJava2.0相关的类库。
compile 'io.reactivex.rxjava2:rxjava:2.0.1'

compile 'io.reactivex.rxjava2:rxandroid:2.0.1'

正确使用姿势:

第一步:创建连载小说(被观察者)

//被观察者
        Observable novel=Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("连载1");
                emitter.onNext("连载2");
                emitter.onNext("连载3");
                emitter.onComplete();
            }
        });

Observable中文意思就是被观察者,通过create方法生成对象,里面放的参数ObservableOnSubscribe<T>,可以理解为一个计划表,泛型T是要操作对象的类型,重写subscribe方法,里面写具体的计划,本文的例子就是推送连载1、连载2和连载3,在subscribe中的ObservableEmitter<String>对象的Emitter是发射器的意思。ObservableEmitter有三种发射的方法,分别是void onNext(T value)、void onError(Throwable error)、void onComplete(),onNext方法可以无限调用,Observer(观察者)所有的都能接收到,onError和onComplete是互斥的,Observer(观察者)只能接收到一个,OnComplete可以重复调用,但是Observer(观察者)只会接收一次,而onError不可以重复调用,第二次调用就会报异常。

第二步:创建读者(观察者)

//观察者
        Observer<String> reader=new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                mDisposable=d;
                Log.e(TAG,"onSubscribe");
            }
        <span class="hljs-meta">@Override</span>
        <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">onNext</span><span class="hljs-params">(String value)</span> </span>{
            <span class="hljs-keyword">if</span> (<span class="hljs-string">"2"</span>.equals(value)){
                mDisposable.dispose();
                <span class="hljs-keyword">return</span>;
            }
            Log.e(TAG,<span class="hljs-string">"onNext:"</span>+value);
        }

        <span class="hljs-meta">@Override</span>
        <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">onError</span><span class="hljs-params">(Throwable e)</span> </span>{
            Log.e(TAG,<span class="hljs-string">"onError="</span>+e.getMessage());
        }

        <span class="hljs-meta">@Override</span>
        <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">onComplete</span><span class="hljs-params">()</span> </span>{
            Log.e(TAG,<span class="hljs-string">"onComplete()"</span>);
        }
    };

通过new创建接口,并实现其内部的方法,看方法其实就应该差不多知道干嘛的,onNext、onError、onComplete都是跟被观察者发射的方法一一对应的,这里就相当于接收了。onSubscribe(Disposable d)里面的Disposable对象要说一下,Disposable英文意思是可随意使用的,这里就相当于读者和连载小说的订阅关系,如果读者不想再订阅该小说了,可以调用 mDisposable.dispose()取消订阅,此时连载小说更新的时候就不会再推送给读者了。

第三步:读者和连载小说建立订阅关系

novel.subscribe(reader);//一行代码搞定

在这里细心的你,可能已经发现了怎么是小说订阅了读者,之所以这样,是因为RxJava主要是想保持自己的链式编程,不得不把Observable(被观察者)放在前面,这里大家可以理解为小说被读者订阅了。

这里我们先看一下输出效果


输出效果

小结一下:这就是RxJava2.0最最简单的用法,创建小说,创建读者,建立订阅关系,记住这三步,你就能实现一个最简单的RxJava2.0的用法。

RxJava2.0的异步和链式编程

前言里面有提到,RxJava是支持异步的,但是RxJava是如何做到的呢?这里就需要Scheduler。Scheduler,英文名调度器,它是RxJava用来控制线程。当我们没有设置的时候,RxJava遵循哪个线程产生就在哪个线程消费的原则,也就是说线程不会产生变化,始终在同一个。然后我们一般使用RxJava都是后台执行,前台调用,本着这个原则,我们需要调用observeOn(AndroidSchedulers.mainThread()),observeOn是事件回调的线程,AndroidSchedulers.mainThread()一看就知道是主线程,subscribeOn(Schedulers.io()),subscribeOn是事件执行的线程,Schedulers.io()是子线程,这里也可以用Schedulers.newThread(),只不过io线程可以重用空闲的线程,因此多数情况下 io() 比 newThread() 更有效率。前面的代码根据异步和链式编程的原则,我们可以写成

 Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("连载1");
                emitter.onNext("连载2");
                emitter.onNext("连载3");
                emitter.onComplete();
            }
        })
                .observeOn(AndroidSchedulers.mainThread())//回调在主线程
                .subscribeOn(Schedulers.io())//执行在io线程
                .subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.e(TAG,"onSubscribe");
                    }
                <span class="hljs-meta">@Override</span>
                <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">onNext</span><span class="hljs-params">(String value)</span> </span>{
                    Log.e(TAG,<span class="hljs-string">"onNext:"</span>+value);
                }

                <span class="hljs-meta">@Override</span>
                <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">onError</span><span class="hljs-params">(Throwable e)</span> </span>{
                    Log.e(TAG,<span class="hljs-string">"onError="</span>+e.getMessage());
                }

                <span class="hljs-meta">@Override</span>
                <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">onComplete</span><span class="hljs-params">()</span> </span>{
                    Log.e(TAG,<span class="hljs-string">"onComplete()"</span>);
                }
            });

这里就是RxJava最常用的写法,异步+链式编程,还要再说一下,subscribe的方法重载,subscribe()方法里什么参数也不放是空实现,也就是说连载小说无论出什么连载,读者都不关心,推送过来了也不读,如果读者只关心onNext方法里的内容,可以直接重载subscribe(Consumer<? spuer T> onNext)这个方法,会减少代码,当然如果是初学者还是建议创建Observer对象。


subscrib的方法重载

应用场景

说了这么多RxJava2.0的用法,你一定要问了到底在什么情况下使用?下面先给大家介绍一下典型的场景。
一、与Retrofit联用
Retrofit+RxJava的上网模式已经非常火了,如果有不了解的可以看笔者的这篇文章https://www.jianshu.com/writer#/notebooks/5118090/notes/25405151
二、Rxpermissions等类库的使用
基于RxJava的开源类库Rxpermissions、RxBinding以及RxBus在很多项目中已经非常常见,并且被证明了是极其好用的。
三、所有用到异步的地方
因为RxJava就是一个支持异步的链式编程,所以所有的用到异步的地方,我们都可以用RxJava来完成,下面给大家举几个例子。
定时执行任务

 Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(123);
                sleep(3000);
                emitter.onNext(456);
            }
        }).observeOn(AndroidSchedulers.mainThread())
                .subscribeOn(Schedulers.io())
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.e(TAG,integer+"");
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                }
            }, <span class="hljs-keyword">new</span> Action() {
                <span class="hljs-meta">@Override</span>
                <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">run</span><span class="hljs-params">()</span> <span class="hljs-keyword">throws</span> Exception </span>{

                }
            });

看完上面的代码你肯定在想,这么多代码,干嘛不直接new Handler().postDelayed()。如果你的程序线程里面做的操作很简单,那么你用new Handler().postDelayed()无所谓,但是如果你的操作很复杂,那么这时候就体现出了RxJava的好处了,借用扔物线大神的一句话就是"随着程序逻辑变得越来越复杂,RxJava依然能够保持简洁"。
下面来说一个复杂的操作,比如我们要依次加载10张图片(加载图片是耗时过程),其中第六张我们延时3秒加载,第7张我们复制到sd卡里,第8张我们要上网络,那么请问你要怎么做,如果用Handler,必然是各种嵌套,各种逻辑复杂得让你再看一眼都难受,但是如果使用RxJava呢?

Observable.create(new ObservableOnSubscribe<Drawable>() {
            @Override
            public void subscribe(ObservableEmitter<Drawable> emitter) throws Exception {
                for (int i=0;i<drawableRes.length;i++){
                    Drawable drawable=getResources().getDrawable(drawableRes[i]);
                    //第6个图片延时3秒后架子
                    if (i==5){
                        sleep(3000);
                    }
                    //复制第7张图片到sd卡
                    if (i==6){
                        Bitmap bitmap=((BitmapDrawable)drawable).getBitmap();
                        saveBitmap(bitmap,"test.png", Bitmap.CompressFormat.PNG);
                    }
                    //上传到网络
                    if (i==7){
                        updateIcon(drawable);
                    }
                    emitter.onNext(drawable);
                }
            }
        }).subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<Drawable>() {
                    @Override
                    public void accept(Drawable drawable) throws Exception {
                           //回调后在UI界面上展示出来
                    }
                });

没有任何嵌套,逻辑依然简洁,这就是RxJava的好处。

总结

RxJava2.0是非常好用的一个异步链式库,遵循观察者模式。理解观察者模式可以根据连载小说和读者的关系,被观察者是连载小说,观察者是读者,读者订阅小说,当小说有了新的连载推送给读者,这就是观察者模式;创建RxJava最简单的步骤,一、创建被观察者对象,二、创建观者对象,三创建订阅关系;RxJava2.0的应用场景,只要记得一句话就是所有的异步都可以用RxJava来做就可以了,尤其是复杂的场景,越是复杂的场景越能体现RxJava的好处。关于RxJava的文章,笔者将会继续推出两篇,一篇是《RxJava从入门到进阶》讲的是RxJava的一些进阶操作,例如变换、常用操作符和背压;另一篇是RxJava相关的类库的介绍和使用,例如文章中提到的RxBinding、RxPerssions等等。如果喜欢笔者,可以关注一波,谢谢!

最后放上我的github地址(本次demo的代码基本都在文章上了,不下也可以):https://github.com/kaka10xiaobang/RxJavaDemo

      </div>
    </div>
</div>

没有更多推荐了,返回首页