RxJava的理解

先说什么是Rxjava，在Github主页上的介绍是“RxJava is a Java VM implementation of Reactive Extensions:”。我的理解本质上它是一个实现异步操作的库。
那为什么不用现成的AsyncTask / Handler这些呢？也就是说Rxjava比他们的优势在哪里？
我觉得主要是简洁，RxJava使用链式的调用方式使得程序随着逻辑的复杂，仍然能保持整洁。

Rxjava的观察者模式

RxJava 有四个基本概念：Observable (可观察者，即被观察者)、 Observer (观察者)、 subscribe (订阅)和事件。
Observable 和 Observer 通过 subscribe() 方法实现订阅关系，从而 Observable 可以在需要的时候发出事件来通知 Observer。
Rxjava的回调方法定义了三种类型：

• onNext():普通事件。
• onCompleted():事件完结调用，当不会再有onNext调用时，需要调用onCompleted作为事件的完结。
• onError():事件队列异常。在事件处理过程中出异常时，onError() 会被触发，同时队列自动终止，不允许再有事件发出。

也就是说在一个正确运行的事件序列中, onCompleted() 和 onError() 有且只有一个，并且是事件序列中的最后一个。
RxJava 的观察者模式大致如下图：

基本实现

Rxjava的基本实现分为三个部分：

创建 Observer

Observer 即观察者，它决定事件触发的时候将有怎样的行为。
在Rxjava中有两种实现方式：

一、使用Observer

Observer<String> observer = new Observer<String>() {
    @Override
    public void onNext(String s) {
    }

    @Override
    public void onCompleted() {
    }

    @Override
    public void onError(Throwable e) {
    }
};

二、使用Subscriber

Subscriber<String> subscriber = new Subscriber<String>() {
    @Override
    public void onNext(String s) {
    }

    @Override
    public void onCompleted() {
    }

    @Override
    public void onError(Throwable e) {
    }
};

三、两者的区别

不仅基本使用方式一样，实质上，在 RxJava 的 subscribe 过程中，Observer 也总是会先被转换成一个 Subscriber 再使用。所以如果你只想使用基本功能，选择 Observer 和 Subscriber 是完全一样的。它们的区别对于使用者来说主要有两点：

• onStart(): 这是 Subscriber 增加的方法。它会在 subscribe 刚开始，而事件还未发送之前被调用，可以用于做一些准备工作，例如数据的清零或重置。这是一个可选方法，默认情况下它的实现为空。需要注意的是，如果对准备工作的线程有要求（例如弹出一个显示进度的对话框，这必须在主线程执行）， onStart() 就不适用了，因为它总是在 subscribe 所发生的线程被调用，而不能指定线程。要在指定的线程来做准备工作，可以使用 doOnSubscribe() 方法。
• unsubscribe(): 这是 Subscriber 所实现的另一个接口 Subscription 的方法，用于取消订阅。在这个方法被调用后，Subscriber 将不再接收事件。一般在这个方法调用前，可以使用 isUnsubscribed() 先判断一下状态。 unsubscribe() 这个方法很重要，因为在 subscribe() 之后， Observable 会持有 Subscriber 的引用，这个引用如果不能及时被释放，将有内存泄露的风险。所以最好保持一个原则：要在不再使用的时候尽快在合适的地方（例如 onPause() onStop() 等方法中）调用 unsubscribe() 来解除引用关系，以避免内存泄露的发生。

创建 Observable

Observable 即被观察者，它决定什么时候触发事件以及触发怎样的事件。

基本创建方法

Observable observable = Observable.create(new Observable.OnSubscribe<String>() {
    @Override
    public void call(Subscriber<? super String> subscriber) {
        subscriber.onNext("a");
        subscriber.onNext("b");
        subscriber.onNext("c");
        subscriber.onCompleted();
    }
});

快捷创建

一、just(T...): 将传入的参数依次发送出来

Observable observable = Observable.just("a", "b", "c");
// 将会依次调用：
// onNext("a");
// onNext("b");
// onNext("c");
// onCompleted();

二、from(T[]) / from(Iterable<? extends T>) : 将传入的数组或 Iterable 拆分成具体对象后，依次发送出来

String[] words = {"a", "b", "c"};
Observable observable = Observable.from(words);
// 将会依次调用：
// onNext("a");
// onNext("b");
// onNext("c");
// onCompleted();

Subscribe (订阅)

创建了 Observable 和 Observer 之后，再用 subscribe() 方法将它们联结起来，整条链子就可以工作了。

不完整的回调

Action1<String> onNextAction = new Action1<String>() {
    @Override
    public void call(String s) {
    }
};
Action1<Throwable> onErrorAction = new Action1<Throwable>() {
    @Override
    public void call(Throwable throwable) {
    }
};
Action0 onCompletedAction = new Action0() {
    @Override
    public void call() {
    }
};

// 自动创建 Subscriber ，并使用 onNextAction 来定义 onNext()
observable.subscribe(onNextAction);
// 自动创建 Subscriber ，并使用 onNextAction 和 onErrorAction 来定义 onNext() 和 onError()
observable.subscribe(onNextAction, onErrorAction);
// 自动创建 Subscriber ，并使用 onNextAction、 onErrorAction 和 onCompletedAction 来定义 onNext()、 onError() 和 onCompleted()
observable.subscribe(onNextAction, onErrorAction, onCompletedAction);

线程控制-Scheduler

前面也说了，RxJava 是一个异步的库，而Scheduler就是用来进行线程调用的。在不指定线程的情况下， RxJava 遵循的是线程不变的原则，即：在哪个线程调用 subscribe()，就在哪个线程生产事件；在哪个线程生产事件，就在哪个线程消费事件。如果需要切换线程，就需要用到 Scheduler （调度器）。
Scheduler的种类：

• Schedulers.immediate()
  直接在当前线程运行，相当于不指定线程。这是默认的 Scheduler。
• Schedulers.newThread()
  总是启用新线程，并在新线程执行操作。
• Schedulers.io()
  I/O 操作（读写文件、读写数据库、网络信息交互等）所使用的 Scheduler。行为模式和 newThread() 差不多，区别在于 io() 的内部实现是是用一个无数量上限的线程池，可以重用空闲的线程，因此多数情况下 io() 比 newThread() 更有效率。不要把计算工作放在 io() 中，可以避免创建不必要的线程。
• AndroidSchedulers.mainThread()
  它指定的操作将在 Android 主线程运行。
• Schedulers.computation()
  计算所使用的 Scheduler。这个计算指的是 CPU 密集型计算，即不会被 I/O 等操作限制性能的操作，例如图形的计算。这个 Scheduler 使用的固定的线程池，大小为 CPU 核数。不要把 I/O 操作放在 computation() 中，否则 I/O 操作的等待时间会浪费 CPU。

有了这几个 Scheduler ，就可以使用 subscribeOn() 和 observeOn() 两个方法来对线程进行控制了。 * subscribeOn(): 指定 subscribe() 所发生的线程，即 Observable.OnSubscribe 被激活时所处的线程。或者叫做事件产生的线程。 * observeOn(): 指定 Subscriber 所运行在的线程。或者叫做事件消费的线程。

Observable.just(1, 2, 3, 4) // IO 线程，由 subscribeOn() 指定
    .subscribeOn(Schedulers.io())
    .observeOn(Schedulers.newThread())
    .map(mapOperator) // 新线程，由 observeOn() 指定
    .observeOn(Schedulers.io())
    .map(mapOperator2) // IO 线程，由 observeOn() 指定
    .observeOn(AndroidSchedulers.mainThread) 
    .subscribe(subscriber);  // Android 主线程，由 observeOn() 指定

我的理解是subscribeOn向上指定线程，observeOn向下指定线程。不同于 observeOn() ， subscribeOn() 的位置放在哪里都可以，但它是只能调用一次的。

操作符

变换

所谓变换，就是将事件序列中的对象或整个序列进行加工处理，转换成不同的事件或事件序列。

• map()
  将事件的参数类型进行转换

Observable.just("images/logo.png") // 输入类型 String
    .map(new Func1<String, Bitmap>() {
        @Override
        public Bitmap call(String filePath) { // 参数类型 String
            return getBitmapFromPath(filePath); // 返回类型 Bitmap
        }
    })
    .subscribe(new Action1<Bitmap>() {
        @Override
        public void call(Bitmap bitmap) { // 参数类型 Bitmap
            showBitmap(bitmap);
        }
    });

• flatMap()
  flatMap操作符用于发射的一个数据序列，而这些数据同时本身拥有发射Observable。flatMap是以铺平序列的方式，然后合并这些Observables发射的数据，最后将合并后的结果作为最终的Observable。但是，flatMap()可能交错的发送事件，最终结果的顺序可能并是不原始Observable发送时的顺序。
  例子，要打印出每个学生所需要修的所有课程的名称：

Student[] students = ...;
Observable.from(students)
    .flatMap(new Func1<Student, Observable<Course>>() {
        @Override
        public Observable<Course> call(Student student) {
            return Observable.from(student.getCourses());
        }
    })
    .subscribe(subscriber);

过滤

• filter()

//分数大于80分的学生
Observable.from(mLists)  
        .filter(new Func1<Student, Boolean>() {  
            @Override  
            public Boolean call(Student student) {  
                return student.getGrade()>80;  
            }  
        })  
        .subscribe(subscriber);  

• take()
  take操作符是用整数N来作为一个参数,把源Observable产生的结果，提取前面的N个提交给订阅者，而忽略后面的

//仅提交前五个
Observable.from(mLists)  
        .take(5)
        .subscribe(subscriber);  

• takeLast()
  takeLast操作符是把源Observable产生的结果的后n项提交给订阅者，提交时机是Observable发布onCompleted通知之时。
• takeFirst()
  takeFirst操作符类似于take操作符，同时也类似于first操作符，都是获取源Observable产生的结果列表中符合指定条件的前一个或多个，与first操作符不同的是，first操作符如果获取不到数据，则会抛出NoSuchElementException异常，而takeFirst则会返回一个空的Observable，该Observable只有onCompleted通知而没有onNext发送Observable。

Observable.from(mLists)  
        .takeFirst(new Func1<Student, Boolean>() {  
            @Override  
            public Boolean call(Student student) {  
                return student.getName().startsWith("B");  
            }  
        })  
        .subscribe(subscriber);     

• distinct()
  distinct操作符对源Observable产生的结果进行过滤，把重复的结果过滤掉，只输出不重复的结果给订阅者。无参函数。
• 其他还有像first(),last(),timeout(),sample(),elementAt()等

其他

其他的一些操作符还有很多，可以参考这些：
RxJava之转换操作符
RxJava之过滤操作符
RxJava之错误处理
RxJava之组合操作符
RxJava之条件和布尔操作符