令人激动的 Rxjava

转自：https://bluzwong.github.io

前言

Rxjava 到底有什么用呢？一句话的定义:
Reactive Extensions for the JVM – a library for composing asynchronous and event-based programs using observable sequences for the Java VM.。处理基于事件的异步问题。

让我们通过一个情形来看看如何理解这个定义。

情形

假设现在有三个运行比较慢的方法，他们可能是网络接口、也可能是一些复杂的运算，总之运行这些方法比较慢，在android中会阻塞主线程。抽象出来，大概是这样：

    public static int slowGetA() throws InterruptedException {        /// ... bala bala        Thread.sleep(200);        return new Random().nextInt(5);    }    public static int slowGetB() throws InterruptedException {        /// ... bala bala        Thread.sleep(200);        return new Random().nextInt(100);    }    public static int slowAdd(int a, int b) throws InterruptedException {        /// ... bala bala        Thread.sleep(200);        return a + b;    }

slowGetA() 和 slowGetB() 不依赖于其他数据，可以直接拿到返回值。slowAdd 需要之前两个方法的返回值作为参数，再去得到结果。这样的情形其实是挺常见的，比如先登录请求，获取tokon 或者其他一些东西，然后在后面的其他请求带上 token。

常规实现

Excuse me? 这有什么难的？
先定义回调接口：

    // 情形简化需要，处理异常情况等省略    interface FooListener {        void onComplete(int result);    }

再把这几个方法封装成异步回调的方式:

    // 情形简化需要，这里只做简单封装，类似于一些网络请求库的异步回调    public static void asyncGetA(final FooListener listener) {        new Thread(new Runnable() {            @Override            public void run() {                int a = -1;                try {                    a = slowGetA();                } catch (InterruptedException e) {                    e.printStackTrace();                }                listener.onComplete(a);            }        }).start();    }    public static void asyncGetB(final FooListener listener) {        new Thread(new Runnable() {            @Override            public void run() {                int a = -1;                try {                    a = slowGetB();                } catch (InterruptedException e) {                    e.printStackTrace();                }                listener.onComplete(a);            }        }).start();    }    public static void asyncAdd(final int a, final int b, final FooListener listener) {        new Thread(new Runnable() {            @Override            public void run() {                int result = -1;                try {                    result = slowAdd(a, b);                } catch (InterruptedException e) {                    e.printStackTrace();                }                listener.onComplete(result);            }        }).start();    }

最后，去把他们都组合起来：

    // 由于情形简化需要以及笔者能力有限，采取了如下的实现方式。    public void onClick(View view) {        final CountDownLatch latch = new CountDownLatch(2);        final int[] a = new int[1];        final int[] b = new int[1];        asyncGetA(new FooListener() {            @Override            public void onComplete(int _a) {                // 获取到了第一个返回值                // CountDownLatch 计数器减一                a[0] = _a;                latch.countDown();            }        });        asyncGetB(new FooListener() {            @Override            public void onComplete(int _b) {                // 获取到了第二个返回值                // CountDownLatch 计数器减一                b[0] = _b;                latch.countDown();            }        });        new Thread(new Runnable() {            @Override            public void run() {                try {                    // 开启新的一个线程等待计数器减为0，也就是等待两个返回值都获取完成。                    latch.await();                } catch (InterruptedException e) {                    e.printStackTrace();                }                // 把上面获得的两个返回值作为参数，请求最后的结果。                // 这里非主线程，也可以直接使用阻塞的同步方法                asyncAdd(a[0], b[0], new FooListener() {                    @Override                    public void onComplete(final int result) {                        runOnUiThread(new Runnable() {                            @Override                            public void run() {                                // 拿到了最终的结果，在主线程中更新UI                                tvNormal.setText("result is : " + result);                            }                        });                    }                });            }        }).start();    }

蛤蛤 Too Simple!，这不就好了嘛！

慢着

这个缩进让我想起了某个 需要带刻度尺写代码的语言，这一层嵌套着一层的结构，看着有点不怎么舒服。如果后面还要再去请求其他的呢？其中有些接口出现了异常呢？有些方法需要保存或者读取本地缓存呢？如果需要取消掉这些请求呢。。。。
OMG，Callback Hell!

Rxjava 实现！

来看看Rxjava是如何优雅的处理这种情形。
第一步，同样的，先把这三个会阻塞的方法进行封装，包装成 Rxjava 的 Observable 。

    // 情形简化需要，只做简单封装    public static Observable<Integer> rxGetA() {        return Observable.defer(new Func0<Observable<Integer>>() {            @Override            public Observable<Integer> call() {                int result = -1;                try {                    result = slowGetA();                } catch (InterruptedException e) {                    e.printStackTrace();                }                return Observable.just(result);            }        });    }    public static Observable<Integer> rxGetB() {        return Observable.defer(new Func0<Observable<Integer>>() {            @Override            public Observable<Integer> call() {                int result = -1;                try {                    result = slowGetB();                } catch (InterruptedException e) {                    e.printStackTrace();                }                return Observable.just(result);            }        });    }    public static Observable<Integer> rxAdd(int a, int b) {        return Observable.defer(new Func0<Observable<Integer>>() {            @Override            public Observable<Integer> call() {                int result = -1;                try {                    result = slowAdd(a, b);                } catch (InterruptedException e) {                    e.printStackTrace();                }                return Observable.just(result);            }        });    }

定义一个中间类，用于持有数据

    class AnB {        public AnB(int a, int b) {            this.a = a;            this.b = b;        }        int a;        int b;    }

组合到一起

    public void onClick(View view) {        // 将两个 Observable 打包到一起。两个 Observable 都执行完成后，        // 在第三个参数的匿名类中 return 返回值，类似于 `AsyncTask` 的 `doInBackground`        Observable.zip(rxGetA(), rxGetB(),                new Func2<Integer, Integer, AnB>() {                    @Override                    public AnB call(Integer a, Integer b) {                        // 用中间类来持有rxGetA()和rxGetB()的结果                        // 如果有类似 Python的Tuple 就方便多了。。                        return new AnB(a, b);                    }                })                // 将打包的数据进一步处理                .flatMap(new Func1<AnB, Observable<Integer>>() {                    @Override                    public Observable<Integer> call(AnB anB) {                        // 从中间类取出两个参数，请求第三个方法获取最后结果                        return rxAdd(anB.a, anB.b);                    }                })                        // 在IO线程进行订阅，也就是上面这些操作都在IO线程中运行，所以不会阻塞主线程                .subscribeOn(Schedulers.io())                        // 在android主线程观察，也就是下面紧接着的一部操作会在主线程运行，所以可以操作UI                .observeOn(AndroidSchedulers.mainThread())                .subscribe(new Action1<Integer>() {                    @Override                    public void call(Integer result) {                        // 操作UI                        tvNormal.setText("result is : " + result);                    }                });    }

“看起来一点也不比上面的方法短，这特么到底哪里好了？”
大熊弟啊，代码高不高、宽不宽暂且不说。用Rxjava逻辑上简单了一个数量级。你看，嵌套地狱不见了！所有的操作都是线性的，一排往下走，类似于写同步调用那般清晰。
“我不管，这个代码太多。”
大熊弟妮别急嘛。。来加上lambda表达式看看：

    // 使用了java8的lambda表达式，由于android原生只支持java7    // 所以需要使用 retrolambda 插件实现对lambda的支持    // 当然啦，更好的解决办法是 原生支持lambda，且和java兼容的Kotlin    public void onClick(View view) {        Observable.zip(rxGetA(), rxGetB(),                AnB::new)                .flatMap(anB -> rxAdd(anB.a, anB.b))                .subscribeOn(Schedulers.io())                .observeOn(AndroidSchedulers.mainThread())                .subscribe(result -> tvRxjava.setText("result is : " + result));    }

这样呢？

Rxjava 大法好

笔者只是展示了Rxjava庞大操作符的冰山一角，Rxjava的操作符简直无所不能，包括错误处理、过滤、转换等。

参考了这些前辈的贡献：
ReactiveX 中文文档 (Rxjava 是ReactiveX 在java的实现)
RxJava Essentials 中文翻译版
深入浅出RxJava
给 Android 开发者的 RxJava 详解

你问我支不支持 Rxjava，我说支持，我就明确告诉你这一点！
用Rxjava也要按照基本法，按照使用的法。当然，我们的决定权也是很重要的。

很惭愧，只做了一些微小的工作。

Demo地址