RxJava与RxKotlin项目实践

What is Rx?

基本概念

RxJava – Reactive Extensions for the JVM – a library for composing asynchronous and event-based programs using observable sequences for the Java VM.

按照官方介绍RxJava是一个在JVM平台上以Observable序列来处理异步和时间的代码库

Netflix发起

Why Rx?

现在Android社区都在广泛的推广和使用RxJava，但是为什么用它以及使用它能带来什么样的好处，我们通过一个具体的案例来研究

用户登录系统需求

假设现在我们有一个微信用户第三方登录功能的需求，这个需求呢很简单，就是实现一个登录界面，用户点击登录跳转到微信进行用户认证，拿到微信的openId然后再接入到自己后台服务器进行登录。这里我们设计一个AccountManager类，这个类里面有2个方法，首先是requestWxOpenId()方法用于跳转微信获得微信的openId,另外一个就是通过openId登录认证的login()

interface AccountManager {
    fun requestWxOpenId(): String

    fun login(wxOpenId: String): User
}

传统代码实现

因为AccountManager这些方法都是服务器访问的接口，是个异步任务，如果直接调用堵塞主线程肯定是不行的，所以我们会封装一个callback出来,回调方法用来处理当接口请求结束后的操作，因为接口请求有可能成功也有可能失败，所以回调接口中包含了两个方法onSuccess和onFaillure

interface OpenIdCallback {
    fun onSuccess(openId: String)
    fun onFailure()
}

interface AccountCallback {
    fun onSuccess(resultl: String)

    fun onFailure()
}

interface AccountManager {
    fun requestWxOpenId(callback: OpenIdCallback): String

    fun login(wxOpenId: String, callback: AccountCallback)
}

AccountManager的实现很简单首先调用requestWxOpenId方法获取到openId后再调用login方法获取用户信息，调用代码如下所示

 private fun clickLogin() {
        val accountManager = AccountManagerIml()
        accountManager.requestWxOpenId(object : OpenIdCallback {
            override fun onSuccess(openId: String) {
                accountManager.login(openId, object : AccountCallback {
                    override fun onSuccess(user: User) {
                        if (!isActivityDestroyed) {
                            runOnUiThread {
                                //update UI
                            }
                        }
                    }

                    override fun onFailure() {
                        //handle error
                    }

                })
            }

            override fun onFailure() {
                //handle error
            }
        })
    }

可以看到整套流程下来，有几个痛点，一个是每一个异步请求我们都需要生命一个callback借口，另外一个是callback嵌套使得代码不清晰，如果再嵌套多几层会使得代码很难看，这就是有名的回调地狱（callback hell），再就是像在Android应用开发中需要在主线程操作UI和相关组件生命周期的判断,这就需要在各个回调中加上各种判断。为了解决这些问题Rx应运而生

使用RX的实现

为了解决上述提到哪些问题，我们看看Rx怎么解决的，首先为了解决不同的callback问题，Rx定义了统一的回调接口Observer

public interface Observer {
    void onCompleted();

    void onError(Throwable e);

    void onNext(T t);
}

通过泛型包装来统一回调接口，Observer回调中封装了三个方法onErro用来处理错误情况，onNext用来处理正常情况下返回结果的回调，onComplete表示整个流程结束的回调。

通过统一泛型回调接口解决了声明多个回调的问题，那么如何解决回调嵌套的问题呢,因为回调嵌套产生的原因是由于数据的链式处理，如果把数据处理都能直接反映链式处理上，最终结果返回给最终的observer就行了，这个Rx使用Observable和对应的操作符来处理链式数据处理

Observable表示一个数据源，在AccountManager的方法中，我们对应的接口就需要修改

interface AccountManager {
    fun requestWxOpenId(): Observable

    fun login(wxOpenId: String):Observable
}

我们调用代码就只需要一个subscriber就行了

    private fun clickLogin(){
        val accountManager = AccountManagerIml2()
        accountManager.requestWxOpenId()
                .flatMap { accountManager.login(it) }
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(object: Subscriber() {
                    override fun onNext(t: User?) {
                        //update ui
                    }

                    override fun onCompleted() {
                    }

                    override fun onError(e: Throwable?) {
                    }
                })
    }

看到上面的代码是不是变得清晰了，如果使用RxKotlin，会更加清晰

    private fun clickLogin() {
        val accountManager = AccountManagerIml2()
        accountManager.requestWxOpenId()
                .flatMap { accountManager.login(it) }
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribeBy(
                        onError = {},
                        onNext = {
                            //update ui 
                        })
    }

可以看到，使用RxJava来封装这些异步操作后，整个代码跟同步操作的代码都非常接近，结构很清晰和明了

What Rx inside is？

要想更好的使用RxJava，就有必要更好更深入的了解RxJava的api，这一部分将深入了解RxJava和RxKotlin的api和部分实现原理

RxJava1 Api探究

事件源

Observable

Observable是最为常用的数据源，Observable对象提供了常用的创建方法,create,just,from等方法

Observable.just("hello")

Observable.from(arrayOf(1, 2, 3, 4, 5))

Observable.create(Observable.OnSubscribe { t ->
        try {
            t.onNext("hello")
            t.onStart()
        } catch (e: Exception) {
            t.onError(e)
        }
    })

Completable

Completable数据源只会触发onComplete和onError回调，通过from()方法可以创建Completable数据源

Completable.fromAction { println("action done") }

Single

Single数据源只会发射一条数据，Single类也有create，just，from等方法用来床架Single数据源对象，subscribe方法只有onSuccess和onError，比方说如下代码

    Single.just(1)
            .subscribeBy(
                    onSuccess ={ println(it) },
                    onError = {}
            )

操作符

操作符可以说是是RxJava中的核心了，通过不同的操作符来实现数据的拼接，转换等等操作从而达到最终的数据结果，RxJava提过了很多的操作符，这里就不一一讲解，主要列出一些常用的

map

用于数据转换，常见的应用场景比方说id应设成名称

Observable.just(1, 2, 3, 4)
           .map {
               when (it) {
                   1 -> "Jane"
                   2 -> "Mike"
                   3 -> "Mary"
                   4 -> "tom"
                   else -> "noName"
               }
           }
           .subscribeBy(onNext = { println(it) })

输出内容为

Jane
Mike
Mary
tom

flatMap

flatMap操作类似于Map，但是Map转换是T -> D，但是flatMap是T -> Observable

fun getInfoById(id: Int): Observable {
    //模拟耗时请求
    return Observable.just(id)
}

Observable.just(1, 2, 3, 4)
            .flatMap { getInfoById(it) }
            .subscribeBy(onNext = { println(it)})
           

这里getInfoById我们假设是一个网络请求或者数据库操作之类的耗时操作，它返回Observable对象，最后subscriber中onNext中接受到的还是Int数据

输出结果

1
2
3
4

filter

filter用于过滤数据

Observable.just(1,2,3,4)
            .filter {  it > 2 }
            .subscribeBy(onNext = { println(it)})

输出结果

3
4

....

RxJava中操作符可以说是非常非常多，想了解更多可以查看官方文档Rx操作符

线程调度

线程调度在RxJava可以说是非常精简，简单到一两行代码来实现线程切换

    Observable.just(1,2,3,4)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribeBy(onNext = { println(it)})

上面代码中通过切换android ui线程和io线程是的回调方法都运行在ui线程，Observable数据源操作在io线程中运行

Transformer

我们在使用RxJava的过程中，通常都会用到线程切换，耗时操作在io线程，subscriber回调在主线程

    Observable.just(1,2,3,4)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribeBy(onNext = { println(it)})

对于多个地方都总是要重复调用subscirbeOn和observeOn这两个方法，我们会想到去封装一下，比方说增加一个方法

fun schedule(observable: Observable): Observable {
    return observable.subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
}

这样我们就可以这样调用

schedule(observable)
            .subscribeBy(onNext = { println(it)})

这样做虽然加了一层封装，但是打破了整个Observable的链式调用，这就显得不太好看

好在RxJava有Transformer，通过与Observable的compose()操作符使用来组合Observable操作

Transformer就是一个Func1, Observable>，可以通过它将一种类型的Observable转换成另一种类型的Observable

fun  applySchedulers(): Observable.Transformer {
    return Observable.Transformer { observable ->
        observable.subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
    }
}

我们创建一个applySchedulers方法返回一个Transformer对象，这时候我们就可以直接链式切换线程了

observable.compose(applySchedulers())
            .subscribeBy(onNext = { println(it)})

Subject

Subject是一个很特殊的接口，它即实现了Observable接口又实现了Observer接口，也就是说它既是一个数据发射方又是一个数据接收方

AsyncSubject

AsyncSubject注册到的Observer只会在onComplete回调之后接收到最后一个onNext发射出来的数据

  // observer不会接收到数据，因为subject没有调用onComplete
  AsyncSubject