浅谈android热门第三方框架-RxJava

RxJava 是一个 基于事件流、实现异步操作的库。实现异步操作，类似于 Android中的 AsyncTask 、Handler作用。由于RxJava基于事件流的链式调用，所以使得 RxJava逻辑简单，实现优雅，使用简单，
而且随着程序逻辑复杂性的提高，依然能够保持简洁和优雅。相信才接触RxJava的现在肯定还是一脸懵逼状态，那么先举一个生活中的例子介绍其原理，先有个初步印象，后面再结合源码具体讲解。
比如我们去饭店吃饭，点好菜（菜1，菜2…）后交给服务员，服务员拿着菜单向厨房厨师下单，厨师按菜单做好菜后一一送到我们桌子上给我们吃，这个过程就可以理解为一次RxJava的使用，这里顾客代表被观察者（Observable）通过订阅（Subscribe ，即这里的服务员）按顺序发送事件（菜1，菜2…）给观察者（Observer及厨房厨师），观察者（Observer） 按顺序接收事件 & 作出对应的响应动作。
如下为demo及相关解释：

public class RxJavaActivity extends Activity {
    private static final String TAG = "Rxjava";
    @Override
    protected void onCreate( Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.tab_activity_layout);


//        分步骤实现方法
//
//         创建被观察者 Observable 对象
//         create() 是 RxJava 最基本的创造事件序列的方法
//         此处传入了一个 OnSubscribe 对象参数
//         当 Observable 被订阅时，OnSubscribe 的 call() 方法会自动被调用，即事件序列就会依照设定依次被触发
//         即观察者会依次调用对应事件的复写方法从而响应事件
//         从而实现被观察者调用了观察者的回调方法 & 由被观察者向观察者的事件传递，即观察者模式
        Observable<String> observable =Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            //重写的subscribe（）里定义需要发送的事件
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                // 通过 ObservableEmitter类对象产生事件并通知观察者
                // ObservableEmitter类介绍
                // a. 定义：事件发射器
                // b. 作用：定义需要发送的事件 & 向观察者发送事件
                Log.d(TAG,"调用传递数据");
                e.onNext("123");
                e.onNext("abc");
                e.onNext("wwww");
                e.onComplete();
//                e.onError(null);
            }
        });

//         创建观察者 （Observer ）对象
        Observer<String> observer = new Observer<String>() {
            @Override
            // 创建对象时通过对应复写对应事件方法 从而 响应对应事件
            // 观察者接收事件前，默认最先调用复写 onSubscribe（）
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "开始采用subscribe连接");
            }

            @Override
            // 当被观察者生产Next事件 & 观察者接收到时，会调用该复写方法 进行响应
            public void onNext(String value) {
                Log.d(TAG, "对Next事件"+ value +"作出响应"  );
            }

            @Override
            // 当被观察者生产Error事件& 观察者接收到时，会调用该复写方法 进行响应
            public void onError(Throwable e) {
                Log.d(TAG, "对Error事件作出响应");
            }

            //****注意****
            //onError方法与onComplete()不能同时调用，是互斥的，不然会导致闪退

            @Override
            // 当被观察者生产Complete事件& 观察者接收到时，会调用该复写方法 进行响应
            public void onComplete() {
                Log.d(TAG, "对Complete事件作出响应");
            }
        };
        observable.subscribe(observer);
//        扩展方法
        Observable observable1 = Observable.just("A","B","C");
        // 将会依次调用：
        // onNext("A");
        // onNext("B");
        // onNext("C");
        // onCompleted();
        String[] words = {"a","b","c"};
        Observable observable2 = Observable.fromArray(words);
        observable1.subscribe(observer);
        observable2.subscribe(observer);
        //基于事件流的链式调用方式
        Observable.create(new ObservableOnSubscribe<Integer>() {
            // 1. 创建被观察者 & 生产事件
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
                e.onComplete();
            }
            // 2. 通过通过订阅（subscribe）连接观察者和被观察者
            // 3. 创建观察者 & 定义响应事件的行为
        }).subscribe(new Observer<Integer>() {
            @Override
            // 默认最先调用复写的 onSubscribe（）
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "开始采用subscribe连接");
            }

            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "对Next事件"+ value +"作出响应"  );
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "对Error事件作出响应");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "对Complete事件作出响应");
            }
        });
    }
}

常用操作符
常规创建
1，create（） 创建一个被观察者对象
2，just()快速创建一个被观察者对象 ，直接发送被传入的事件，但最多只能发送10个参数
3，fromArray 跟just一样是快速创建，但fromArray没有参数个数限制
4，fromIterable 快速创建1个被观察者对象， 直接发送 传入的集合List数据
延迟创建
5，defer（）直到有观察者（Observer ）订阅时，才动态创建被观察者对象（Observable） & 发送事件。
6，timer() 延迟指定时间后，调用一次 onNext(0) ,默认在新线程中执行
7,interval() 每隔指定时间 就发送 事件，从0开始、无限递增1的的整数序列 ，默认在新线程中执行 ，demo 无条件轮询
8，intervalRange（）每隔指定时间 就发送 事件，可指定发送的数据的数量
9，range（）连续发送 1个事件序列，可指定范围
10，rangeLong() 与range类似，改方法支持数据类型为Long
功能行操作符

1，线程控制（切换和调度） subscribeOn（指定被观察者只第一次指定有效） observeOn（指定观察者，每次指定都有效）
指定 被观察者 （Observable） / 观察者（Observer） 的工作线程类型,被观察者和观察者在什么线程中创建，就在什么线程中工作，而我们的需求往往是需要在子线程中做耗时操作（被观察者），在主线程中更新ui（观察者主线程中响应），
采用 RxJava内置的线程调度器（ Scheduler ），即通过 功能性操作符subscribeOn（） & observeOn（）实现。
类型 含义 应用场景
Schedulers.immediate() 当前线程 = 不指定线程 默认
AndroidSchedulers.mainThread() Android主线程 操作UI
Schedulers.newThread() 常规新线程 耗时等操作
Schedulers.io() io操作线程 网络请求、读写文件等io密集型操作
Schedulers.computation() CPU计算操作线程 大量计算操作
2，延迟操作
delay（）使得被观察者延迟一段时间再发送事件
do() 在某个事件的生命周期中调用

3,错误处理 发送事件过程中，遇到错误时的处理机制

4,轮询
重复不断地发送被观察者事件，有条件网络请求轮询 repeatWhen()方法实现 repeat
5，差错重试机制 即当出现错误时，让被观察者（Observable）重新发射数据 retry retryUntil retryWhen
6，变换操作符 对事件序列中的事件 / 整个事件序列 进行加工处理（即变换），使得其转变成不同的事件 / 整个事件序列 常见的操作符有Map(数据类型转换) ,FloatMap(无序),ConcatMap（有序）,Buffer
7，过滤操作符 Filter（过滤特定条件的事件 ）ofType（过滤特定类型的数据）skip skipLast（跳过某个事件）distinct distinctUntilChanged（过滤事件序列中的重复事件或者连续重复事件） take takeLast（设置指定的事件数量，仅发送特定数量的事件） throttleFirst throttleLast（通过设置指定的时间，仅发送该时间内的事件，防抖动功能）Sample（在某段时间内，只发送该段时间内最新（最后）1次事件）firstElement（） / lastElement（）（通过设置指定的位置，过滤在该位置的事件，仅选取第1个元素 / 最后一个元素）elementAt（）（指定接收某个元素（通过 索引值 确定））throttleWithTimeout （） / debounce（） （发送数据事件时，若2次发送事件的间隔＜指定时间，就会丢弃前一次的数据，直到指定时间内都没有新数据发射时才会发送后一次的数据）
8，背压 控制事件流速 的策略 ，异步订阅关系
背景 ： 被观察者 发送事件速度太快，而观察者 来不及接收所有事件，从而导致观察者无法及时响应 / 处理所有发送过来事件的问题，最终导致缓存区溢出、事件丢失 & OOM
Flowable：在 RxJava2.0中，被观察者（Observable）的一种新实现。
随笔写的很粗糙，请见谅，部分demo在在https://github.com/labiqi/RxJavaExample