RXAndroid2.0初学习一

初次学习RXAndroid的demo时候感觉这个东西不太好理解，一遍上班一遍看这东西不是很好的事情，所以我抽出一天时间来查看整个demo中的运行过程，同时了解源码的实现逻辑。发现他功能强大，特别是看了给 Android 开发者的 RxJava 详解 ——扔物线 对RxJava的概念以及基本特性做了详细介绍，我感觉好像就是看了一点皮毛，没怎么理解，就是感觉这个就是这么用，感觉代码写的很高深；后面断断续续的看RXAndroid源码demo，跑题了。

第一眼感觉：这货是链式调用，感觉用起来很方便，理解起来需要踏实的看源码，需要调试，因为中间涉及到了主线程和工作线程，整个过程中需要对一些类进行整理，大概翻译一下方法的意思，帮助自己理解。言归正传。

RXAndroid源码：链接：http://pan.baidu.com/s/1cgyjs6 密码：ee5m

1、订阅者模式，说白了就是监听，就是你有变化通知我，观察这根据事件才取相应的动作。

2、源码查看：

1

@Override protected void onCreate(Bundle savedInstanceState) {    super.onCreate(savedInstanceState);    setContentView(R.layout.main_activity);    findViewById(R.id.button_run_scheduler).setOnClickListener(new View.OnClickListener() {        @Override public void onClick(View v) {            onRunSchedulerExampleButtonClicked();        }    });}@Override protected void onDestroy() {    super.onDestroy();    disposables.clear();}void onRunSchedulerExampleButtonClicked() {    disposables.add(sampleObservable()        // Run on a background thread        .subscribeOn(Schedulers.io())        // Be notified on the main thread        .observeOn(AndroidSchedulers.mainThread())        .subscribeWith(new DisposableObserver<String>() {            @Override public void onComplete() {                Log.d(TAG, "onComplete()");            }            @Override public void onError(Throwable e) {                Log.e(TAG, "onError()", e);            }            @Override public void onNext(String string) {                Log.d(TAG, "onNext(" + string + ")");            }        }));}static Observable<String> sampleObservable() {    return Observable.defer(new Callable<ObservableSource<? extends String>>() {      @Override public ObservableSource<? extends String> call() throws Exception {            // Do some long running operation            SystemClock.sleep(5000);            return Observable.just("one", "two", "three", "four", "five");        }    });}

sampleObservable()这个方法返回的是一个ObservableDefer的一个对象，这个对象继承了Observable这个类，我们现在解读一下defer这个方法都干了哪些事情：
2
@SchedulerSupport(SchedulerSupport.NONE)public static <T> Observable<T> defer(Callable<? extends ObservableSource<? extends T>> supplier) {    ObjectHelper.requireNonNull(supplier, "supplier is null");    return RxJavaPlugins.onAssembly(new ObservableDefer<T>(supplier));}
3
 ObjectHelper.requireNonNull(supplier, "supplier is null");

这句就不用说了，判断非空的。

4

RxJavaPlugins.onAssembly(new ObservableDefer<T>(supplier));}
这句是其实也没做什么，主要是new一个ObservableDefer对象，上面说过了，这个对象继承了Observable类。sampleObservable()这个方法返回一个ObservableDefer对象，然后

这个对象开始链式调用了。

ObservableDefer.subscribeOn(Schedulers.io())，这个方法的直白翻译是:默认的可以被观察的（可以被订阅的对象）订阅在线程Schedulers.io()中，继续看源码：
5
public final Observable<T> subscribeOn(Scheduler scheduler) {    ObjectHelper.requireNonNull(scheduler, "scheduler is null");    return RxJavaPlugins.onAssembly(new ObservableSubscribeOn<T>(this, scheduler));}

大家又看到上述中熟悉的代码语句，代码实现都是一样的，就是判断RxJavaPlugins中有无设置onObservableAssembly，本文中这个对象为空。后面再细说这个方法的作用。
那么其实就是讲上面Schedulers.io()返回的对象整合成ObservableSubscribeOn，然后再调用下面observeOn方法。我们首先看一下Schedulers.io()都干了什么；
6
public static Scheduler io() {    return RxJavaPlugins.onIoScheduler(IO);}
他返回一个Schedule对象，大家都知道Schedule对象的作用吧，但是不是你想的那样，这Schedule是RXJava中自定义的一个类，继续

先看下IO，

7

IO = RxJavaPlugins.initIoScheduler(new IOTask());
8

public static Scheduler initIoScheduler(@NonNull Callable<Scheduler> defaultScheduler) {    ObjectHelper.requireNonNull(defaultScheduler, "Scheduler Callable can't be null");    Function<? super Callable<Scheduler>, ? extends Scheduler> f = onInitIoHandler;    if (f == null) {        return callRequireNonNull(defaultScheduler);    }    return applyRequireNonNull(f, defaultScheduler);}
onInitIoHandler对象为空，，所以调用callRequireNonNull方法，defaultScheduler=new IOTask(),extends Callable<Scheduler>
9

static Scheduler callRequireNonNull(@NonNull Callable<Scheduler> s) {    try {        return ObjectHelper.requireNonNull(s.call(), "Scheduler Callable result can't be null");    } catch (Throwable ex) {        throw ExceptionHelper.wrapOrThrow(ex);    }}
10

static final class IOTask implements Callable<Scheduler> {    @Override    public Scheduler call() throws Exception {        return IoHolder.DEFAULT;    }}
11

static final class IoHolder {    static final Scheduler DEFAULT = new IoScheduler();}

上述9代码中返回的时候一个IoScheduler的对象。

我们继续说明

ObservableDefer.subscribeOn(Schedulers.io())这段代码都做了什么，其实就是返回new ObservableSubscribeOn<T>(this, scheduler)对象；我们标记为
ObservableSubscribeOn然后

12

observeOn(AndroidSchedulers.mainThread())

13

/** Android-specific Schedulers. */public final class AndroidSchedulers {    private static final class MainHolder {        static final Scheduler DEFAULT = new HandlerScheduler(new Handler(Looper.getMainLooper()));    }    private static final Scheduler MAIN_THREAD = RxAndroidPlugins.initMainThreadScheduler(            new Callable<Scheduler>() {                @Override public Scheduler call() throws Exception {                    return MainHolder.DEFAULT;                }            });    /** A {@link Scheduler} which executes actions on the Android main thread. */    public static Scheduler mainThread() {        return RxAndroidPlugins.onMainThreadScheduler(MAIN_THREAD);    }    /** A {@link Scheduler} which executes actions on {@code looper}. */    public static Scheduler from(Looper looper) {        if (looper == null) throw new NullPointerException("looper == null");        return new HandlerScheduler(new Handler(looper));    }    private AndroidSchedulers() {        throw new AssertionError("No instances.");    }

根据上述代码我们注意查看一下，

14

static final Scheduler DEFAULT = new HandlerScheduler(new Handler(Looper.getMainLooper()));
15

HandlerScheduler(Handler handler) {    this.handler = handler;}

就获得一个主线程的schedule，这个schedule中包含了主线程的handle对象。

16

    private static final Scheduler MAIN_THREAD = RxAndroidPlugins.initMainThreadScheduler(            new Callable<Scheduler>() {                @Override public Scheduler call() throws Exception {                    return MainHolder.DEFAULT;                }            });

这段代码就是返回一个主线程的scheduler，具体实现如下：

17

public static Scheduler initMainThreadScheduler(Callable<Scheduler> scheduler) {    if (scheduler == null) {        throw new NullPointerException("scheduler == null");    }    Function<Callable<Scheduler>, Scheduler> f = onInitMainThreadHandler;    if (f == null) {        return callRequireNonNull(scheduler);    }    return applyRequireNonNull(f, scheduler);}

onInitMainThreadHandler这个对象没有进行设置过，所以为空，这里面直接调用callRequireNonNull(scheduler)，里面直接调用schedule.call()方法进行回调。
此时就将上面代码14获取到的schedule返回给16中的MAIN_THREAD，此时我们再回到12代码块中ObservableSubscribeOn.observeOn(scheduler)；
18
public final Observable<T> observeOn(Scheduler scheduler) {    return observeOn(scheduler, false, bufferSize());}
public final Observable<T> observeOn(Scheduler scheduler, boolean delayError, int bufferSize) {    ObjectHelper.requireNonNull(scheduler, "scheduler is null");    ObjectHelper.verifyPositive(bufferSize, "bufferSize");    return RxJavaPlugins.onAssembly(new ObservableObserveOn<T>(this, scheduler, delayError, bufferSize));}

上述代码中的RxJavaPlugins.onAssembly的方法我们就不说了里面的判断有误初始化默认，本文中未进行设置初始化参数，所以都是RxJavaPlugins.onAssembly传的参数是什么，
返回就是什么，此时返回的是一个新的ObservableObserveOn对象，我们标记为ObservableObserveOn这个对象中包含了一个主线程的schedule，我们继续：
19
.subscribeWith(new DisposableObserver<String>() {    @Override public void onComplete() {        Log.d(TAG, "onComplete()");    }    @Override public void onError(Throwable e) {        Log.e(TAG, "onError()", e);    }    @Override public void onNext(String string) {        Log.d(TAG, "onNext(" + string + ")");    }}));

subscribeWith，从字面理解一下这个方法的意思：与XX进行订阅，其实就是与订阅者（观察者）进行绑定，ObservableObserveOn这个包含有主线程的schedule的可被订阅
订阅运行器与订阅者进行绑定，example：Button.setOnclickListener(new OnclickListner{ public void onclick(View view)}) 其中onclicklistner就是订阅者，button
所在的环境就是ObservableObserveOn；下面我们在看一下订阅者：
20
new DisposableObserver<String>() {    @Override public void onComplete() {        Log.d(TAG, "onComplete()");    }    @Override public void onError(Throwable e) {        Log.e(TAG, "onError()", e);    }    @Override public void onNext(String string) {        Log.d(TAG, "onNext(" + string + ")");    }})
ObservableObserveOn.subscribeWith（DisposableObserver），我们看下源码：
21
Observable中的方法

public final <E extends Observer<? super T>> E subscribeWith(E observer) {    subscribe(observer);    return observer;}

22
路由执行：
Observable中的方法
public final void subscribe(Observer<? super T> observer) {    ObjectHelper.requireNonNull(observer, "observer is null");    try {        observer = RxJavaPlugins.onSubscribe(this, observer);        ObjectHelper.requireNonNull(observer, "Plugin returned null Observer");        subscribeActual(observer);    } catch (NullPointerException e) { // NOPMD        throw e;    } catch (Throwable e) {        Exceptions.throwIfFatal(e);        // can't call onError because no way to know if a Disposable has been set or not        // can't call onSubscribe because the call might have set a Subscription already        RxJavaPlugins.onError(e);        NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");        npe.initCause(e);        throw npe;    }}
subscribeActual是Observable的抽象类，在ObservableObserveOn.subscribeActual(DisposerObserver),继续贴出源码：
23
protected void subscribeActual(Observer<? super T> observer) {    if (scheduler instanceof TrampolineScheduler) {        source.subscribe(observer);    } else {        Scheduler.Worker w = scheduler.createWorker();        source.subscribe(new ObserveOnObserver<T>(observer, w, delayError, bufferSize));    }}

上述代码中的schedule是原来我们设置执行主线程的产生的那个HandlerScheduler，所以上述的代码执行一目了然。source对象我们在说明一下，source对象是在18代码块
中进行传入，其实就是new ObservableObserveon中传入的this，那这个this是谁那？就是ObservableSubscribeOn，此时创建了一个worker对象，后面使用worker对象的时
候在说明，然后继续
24
RxJavaPlugins.onAssembly(new ObservableObserveOn<T>(this, scheduler, delayError, bufferSize));
此时代码已经顺利的执行到了此处，source===ObservableSubscribeOn
25
source.subscribe(new ObserveOnObserver<T>(observer, w, delayError, bufferSize));

我们继续贴源码：
26
public final void subscribe(Observer<? super T> observer) {    ObjectHelper.requireNonNull(observer, "observer is null");    try {        observer = RxJavaPlugins.onSubscribe(this, observer);        ObjectHelper.requireNonNull(observer, "Plugin returned null Observer");        subscribeActual(observer);    } catch (NullPointerException e) { // NOPMD        throw e;    } catch (Throwable e) {        Exceptions.throwIfFatal(e);        // can't call onError because no way to know if a Disposable has been set or not        // can't call onSubscribe because the call might have set a Subscription already        RxJavaPlugins.onError(e);        NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");        npe.initCause(e);        throw npe;    }}

上述代码是在ObservableSubscribeOn类中，执行subscribeActual(observer),observer不是disposeObserver，是后面创建的
27
继续贴出源码：
ObservableSubscribeOn中
public void subscribeActual(final Observer<? super T> s) {    final SubscribeOnObserver<T> parent = new SubscribeOnObserver<T>(s);    s.onSubscribe(parent);    parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));}
执行s.onSubscribe(parent),其中s为ObservableObserveon.ObserveOnObserver,

由于过多的字发表不了，请关注第二篇