RxJava的使用与深入学习

转载请注明出处：http://blog.csdn.net/evan_man/article/details/51292099

简单介绍

    可以将RxJava是一种观察者设计模式的升级版本。使用Rxjava的好处在于，我们可以方便的切换方法的执行线程，对线程动态切换，该过程无需我们自己手动创建和启动线程。使用Rxjava创建的代码虽然出现在同一个线程中，但是我们可以设置使得不同方法在不同线程中执行。上述功能的实现主要归功于RxJava的Scheduler实现，Scheduler 提供了『后台处理，前台回调』的异步机制。

    Schedulers能创建如下几种类型的线程：

• Schedulers.immediate(): 直接在当前线程运行，相当于不指定线程。这是默认的 Scheduler 
• Schedulers.newThread(): 总是启用新线程，并在新线程执行操作 
• Schedulers.io():一个无数量上限的线程池，可以重用空闲的线程 
• Schedulers.computation():Scheduler 使用的固定的线程池，大小为 CPU 核数 
• AndroidSchedulers.mainThread()，它指定的操作将在 Android 主线程运行

    RxJava有四个基本概念：Observable (可观察者，即被观察者)、 Observer (观察者)、 subscribe (订阅)、事件（就是下面会介绍的onNext、onCompleted等方法）。

    Observer， 对象中有onNext()、onCompleted()、onCompleted()和onError()。RxJava 规定，当不会再有新的onNext()发出时，需要触发 onCompleted()方法作为标志。在事件处理过程中出异常时，onError()会被触发，同时队列自动终止，不允许再有事件发出。Observer主要的业务代码大多是编写在其onNext方法中。

    Subscriber，是Observer的升级版本，相对于Observer还多了onStart和unSubscribe方法。onStart方法在执行observable.subscribe(observer)方法时就被调用，不能指定线程，只能执行在subscribe()被调用时的线程。调用unSubscribe方法后，Subscriber将不再接收事件，一般在不使用该SubScriber的时候，需要及时调用该方法，以免OOM。执行observable.subscribe(observer)方法时，Observer会先被转换成一个Subscriber对象。

    Observable，其构造器接受一个Observable.OnSubscribe对象。执行observable.subscribe(observer)方法时，该方法用于将Observer对象注册到observable中，该方法内部逻辑是调用Observer的onStart方法和Observable.OnSubscribe的call方法。Observable.OnSubscribe对象的call方法会调用Observer的onNext、onCompleted方法（不会调用onStart方法）。此外Observable通过如下的方法指定具体方法的执行线程：

• subscribeOn():  
  • 指定 subscribe() 所发生的线程，即 Observable.OnSubscribe 被激活时所处的线程，或者叫做事件产生的线程。 
  • subscribeOn() 的位置放在哪里都可以，但它是只能调用一次，不可以随时切换Observable.OnSubscribe 被激活时所处的线程；当使用了多个 subscribeOn() 的时候，只有第一个 subscribeOn() 起作用。 
• observeOn():  
  • 指定 Subscriber 所运行在的线程。或者叫做事件消费的线程。 
  • 通过 observeOn()的多次调用，程序实现了线程的多次切换，可以随时切换消费事件所在的线程； observeOn() 控制的是它后面的线程。

        

       Rxjava和RxAndroid对应的Github分别为RxJava、RxAndroid。官方给出的介绍特此摘录如下：

       RxJava is a Java VM implementation of Reactive Extensions: a library for composing asynchronous and event-based programs by using observable sequences. It extends the observer pattern to support sequences of data/events and adds operators that allow you to compose sequences together declaratively while abstracting away concerns about things like low-level threading, synchronization, thread-safety and concurrent data structures.

       RxAndroid：Android specific bindings for RxJava. This module adds the minimum classes to RxJava that make writing reactive components in Android applications easy and hassle-free. More specifically, it provides a Scheduler that schedules on the main UI thread or any given Handler.

简单使用（以Android平台为例）

一、引入如下依赖：

compile 'io.reactivex:rxjava:1.1.3'
compile 'io.reactivex:rxandroid:1.1.0'

二、创建Observable对象

Observable observable = Observable.create(new Observable.OnSubscribe() {
    @Override
    public void call(Subscriber subscriber) {
        subscriber.onNext("Hello");
        subscriber.onNext("Hi");
        subscriber.onNext("Aloha");
        subscriber.onCompleted();
    }
});
Observable observable = Observable.just("Hello", "Hi", "Aloha");
String[] words = {"Hello", "Hi", "Aloha"};  Observable observable = Observable.from(words);

注意：上面三种创建方式结果一样。

三、创建Subscribe对象，重写onNext、onCompleted、onError方法

Subscriber subscriber = new Subscriber() {
            @Override
            public void onCompleted() {
            }
            @Override
            public void onError(Throwable e) {
            }
            @Override
            public void onNext(Object o) {
            }
            @Override
            public void onStart() {
                super.onStart();
            }
};

四、将SubScriber和Observable绑定

observable.subscribe(observer); 
observable.subscribe(subscriber);

到此为止我们利用RxJava实现了一个简单的观察者模式。但是并没有使用到线程的动态切换功能，该部分才是RxJava跟普通观察者模式的最大区别；下面我们对该部分如何使用进行介绍。但是在正式介绍线程动态切换方法之前，我们先来了解一下Observable的map和flatmap方法，因为RxJava线程动态切换往往伴随着这两个方法的出现。

五、map&flatMap

map方法

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

FuncX：: 对有参数且有返回值的一类方法的包装

ActionX: 对只有参数没有返回值的一类方法的包装

可以发现map方法的参数的作用就是将上级的String数据转换成一个bitmap对象。正如它的名字一样map，完成了一个映射的功能，下面来看看flatMap对象。

flatMap方法

flatMap() 的原理：

1. 使用传入的事件对象创建一个 Observable 对象；

2. 并不发送这个 Observable, 而是将它激活，于是它开始发送事件；

3. 每一个创建出来的 Observable 发送的事件，都被汇入同一个 Observable ，而这个 Observable 负责将这些事件统一交给 Subscriber 的回调方法。

Student[] students = ...;
Subscriber subscriber = new Subscriber() {
    @Override
    public void onNext(Course course) {
        Log.d(tag, course.getName());
    }
    ...
};
Observable.from(students)
    .flatMap(new Func1>() {
        @Override
        public Observable call(Student student) {
            return Observable.from(student.getCourses());
        }
    })
    .subscribe(subscriber);

flatMap的工作原理图如下

对map和flatmap的介绍就到这里，下面对RxJava的线程动态切换如何使用进行介绍。

六、线程的动态切换

Observable.just(1, 2, 3, 4) 
    .subscribeOn(Schedulers.io()) //决定调用observable.subscribe(subscriber)方法时的执行线程
    .observeOn(Schedulers.newThread()) //决定下面mapOperator方法的执行线程
    .map(mapOperator) 
    .observeOn(Schedulers.io()) //决定下面mapOperator2方法的执行线程
    .map(mapOperator2) 
    .observeOn(AndroidSchedulers.mainThread) //决定下面subscriber对象的onNext()、onCompleted()、onCompleted()和onError()方法执行线程。即UI线程
    .subscribe(subscriber);  

对RxJava如何使用就介绍到这里了，下面我们通过源码分析一下，RxJava的底层实现。

源码分析

 正式分析开始之前，首先确定一下我们这次分析的目标对象和目标方法。

• Observable对象创建的三个方法create、just、from；
• observable.subscribe(observer)内部逻辑是什么，为何会最终执行到Subscriber对象的相关方法；
• Observable中Observable.OnSubscribe对象的call方法何时被调用；
• Subscriber 对象的onStart、unSubscribe、onNext()、onCompleted()、onCompleted()和onError()在何处，何种情况被调用；
• Observable的map和flatMap方法内部实现机制，参数的传递；
• Schedulers如何创建指定的线程，各个线程之间的区别是什么；
• Observable的observeOn和subscribeOn方法的内部实现机制，如何实现线程的切换；

下面我们针对上面列出的顺序依次进行解答。

Observable.class

以下是Observable类中的Fields:

final OnSubscribe onSubscribe;
static final RxJavaObservableExecutionHook hook = RxJavaPlugins.getInstance().getObservableExecutionHook();
//RxJavaPlugins.getInstance()是一个单例模式，获取一个RxJavaPlugins对象，然后这个对象定义了Hook，然而这对Hook并没有做任何事情，至少目前是这样的。
//rxJavaPlugins.getObservableExecutionHook()近似等价于得到一个RxJavaObservableExecutionHook对象，该对象目前不干任何事，完全可以把它看成透明的，你传什么进去它回什么。

下面是Observable的构造器，该构造器并不能被客户直接使用，因为它使用了Protected关键字进行修饰。

Observable()@Observable.class

protected Observable(OnSubscribe f) {
        this.onSubscribe = f;
}

构造器的内容就是对onSubscriber初始化。

Observable对象创建的三个方法create、just、from具体内容如下

create()@Observable.class

public static  Observable create(OnSubscribe f) {
        return new Observable(hook.onCreate(f));
}

RxJavaObservableExecutionHook.onCreate方法内部直接直接将参数f返回，所以hook.onCreate(f)等价于f;

just()@Observable.class

public static  Observable just(final T value) {
        return ScalarSynchronousObservable.create(value); //note1
}
public static  Observable just(T t1, T t2) {
        return from((T[])new Object[] { t1, t2 }); //note2
}

1、final class ScalarSynchronousObservable extends Observable是一个Observable的子类，ScalarSynchronousObservable.create方法参考后面的ScalarSynchronousObservable.class部分

2、调用了Observable的from方法

from()@Observable.class

public static  Observable from(T[] array) { 
        int n = array.length;
        if (n == 0) {
            return empty();//note1
        } else
        if (n == 1) {
            return just(array[0]);//note2
        }
        return create(new OnSubscribeFromArray(array));
}

1、方法返回一个(Observable) EmptyHolder.INSTANCE对象

private static final class EmptyHolder {
        final static Observable