从放弃到入门，8年Android架构师详解——RxJava2.0

前言

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

学习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正是基于观察者模式开发的。

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是要操作对象的类型，重写subscribe方法，里面写具体的计划，本文的例子就是推送连载1、连载2和连载3，在subscribe中的ObservableEmitter对象的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");
            }
            @Override
            public void onNext(String value) {
                if ("2".equals(value)){
                    mDisposable.dispose();
                    return;
                }
                Log.e(TAG,"onNext:"+value);
            }
            @Override
            public void onError(Throwable e) {
                Log.e(TAG,"onError="+e.getMessage());
            }

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

通过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");
                    }

                    @Override
                    public void onNext(String value) {
                        Log.e(TAG,"onNext:"+value);
                    }
                    @Override
                    public void onError(Throwable e) {
                        Log.e(TAG,"onError="+e.getMessage());
                    }
                    @Override
                    public void onComplete() {
                        Log.e(TAG,"onComplete()");
                    }
                });

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

应用场景

说了这么多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 {

                    }
                }, new Action() {
                    @Override
                    public void run() throws Exception {

                    }
                });

看完上面的代码你肯定在想，这么多代码，干嘛不直接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等等。

关于我的Android学习之路

不知不觉自己已经做了几年开发了，由记得刚出来工作的时候感觉自己能牛逼，现在回想起来感觉好无知。懂的越多的时候你才会发现懂的越少。

如果你的知识是一个圆，当你的圆越大时，圆所接触到的外面的世界也就越大。

在我学习的过程中，最开始是在网上找了很多资料，毕竟这些资料是我们开始最快速的学习方法，这里我放上我这些年在网上收集到的资料，然后再以我的工作经验给大家总结一下，让你们少走些弯路，提取一些目前互联网公司最主流的Android开发架构技术，希望能帮助到大家！

Java语言进阶与Android相关技术内核

Android应用是由Java语言进行开发的，SDK也是由Java语言编写，对于Android来说，只要SDK没有用Kotlin重写，那么Java语言是都需要学习的。而且Android APK的后台服务器程序大概率是Java语言构建，所以掌握Java也是一种必然，这就是为什么BAT面试为什么死抠你的Java水平。

APP开发框架体系

APP开发这块知识是现今使用者最多的，并且大多都是CV工程师，程序员界的2-8定律：80%的问题只需要使用20%的知识就可以解决，Android开发也不例外。因而，我们大部分人已经逐步变成了代码搬运工而自己却不知道。代码容易搬运，架构体系却难以复制，要成为架构师，你必须自己亲自去项目实战，读源码，研究原理。

移动架构师专题项目实战

架构师不是天生的，是在项目中磨练起来的，所以，我们学了技术就需要结合项目进行实战训练，那么在Android里面最常用的架构无外乎 MVC，MVP，MVVM，但是这些思想如果和模块化，层次化，组件化混和在一起，那就不是一件那么简单的事了，我们需要一个真正身经百战的架构师才能讲解透彻其中蕴含的深理。

Android高级架构技术；如何系统化学习？

全套体系化高级架构视频；七大主流技术模块，视频+源码+笔记

设计面试和数据结构算法专题；大厂必会，巩固基础

最后

如果你看到了这里，觉得文章写得不错就给个好评呗？如果你觉得那里值得改进的，请给我留言。一定会认真查询，修正不足。谢谢。

最后针对Android程序员，除了上面的知识体系，我这边给大家整理了一些资料，其中分享内容包括不限于高级UI、性能优化、移动架构师、NDK、混合式开发（ReactNative+Weex）微信小程序、Flutter等全方面的Android进阶实践技术；希望能帮助到大家，也节省大家在网上搜索资料的时间来学习，也可以分享动态给身边好友一起学习！

为什么某些人会一直比你优秀，是因为他本身就很优秀还一直在持续努力变得更优秀，而你是不是还在满足于现状内心在窃喜！希望读到这的您能转发分享和关注下我，以后还会更新技术干货，谢谢您的支持！

转发分享+关注，每天获取更多知识点

Android架构师之路很漫长，一起共勉吧！