RXAndroid源码分析(二) 简单的例子

标签（空格分隔）： rxandroid rxjava

---

RxJava: “a library for composing asynchronous and event-based programs using observable sequences for the Java VM” (一个在Java VM上使用可观测的序列来组成异步的、基于事件的程序的库)

RxJava的观察者模式的基本概念
RxJava有四个基本概念:
Observable(可观察者，即被观察者)
Observer(观察者)
subscribe(订阅)
事件

被观察者Observable中有一张计划表OnSubscribe,当订阅者subcribe发出订阅请求时，被订阅的Observable对象的计划表OnSubscribe的call方法会被调用，事件序列就会依照设定依次触发，订阅者去处理。这样由被观察者调用了观察者的回调方法，就实现了由被观察者向观察者的事件传递，即观察者模式。

一个简单的调用例子
这个例子很简单，甚至在实际中没有什么意义，只是通过这个例子，看下代码的回调执行过程。下面是相关代码：

Observable<String> observable = Observable.create( new Observable.OnSubscribe<String>() {  @Override  public void call( Subscriber<? super String> subscriber ) {    Log.d( TAG, "OnSubscribe call: " );    subscriber.onNext( "123" );  }} );observable.subscribe( new Subscriber<String>() {  @Override  public void onCompleted() {    Log.d( TAG, "Subscriber onCompleted: " );  }  @Override  public void onError( Throwable e ) {    Log.d( TAG, "Subscriber onError: "  );  }  @Override  public void onNext( String s ) {    Log.d( TAG, "Subscriber onNext: " + s );  }} );

这段代码很容易，整个过程分为
a.创建一个被观察者Observable对象，同时新建一个OnSubscribe，当这个计划表被触发时，通知相关的订阅者(类似观察者角色)。
b.订阅者subscribe执行订阅，像Observable发出命令，当Observable被订阅时，计划表OnSubscribe的call方法就会执行，事件序列就会依照计划表中的逻辑触发。

下面详细分析
1.Observable.create(OnSubscribe f)
public static Observable create(OnSubscribe f) {
return new Observable(hook.onCreate(f));
}
这里的hook是一个插件管理，可以暂时忽略它，默认返回的是本身，比如hoon.onCreate(f),默认返回的就是f这个对象。在Observable构造方法中，将f赋值给其成员变量onSubscribe，这样一个计划表就完成建立了,同时被观察者对象也被建立。

2.Observable.subscribe(Subscriber subscriber)

public final Subscription subscribe(Subscriber<? super T> subscriber) {    return Observable.subscribe(subscriber, this);}static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T> observable) {    // validate and proceed    ...    // new Subscriber so onStart it    subscriber.onStart();    // if not already wrapped    if (!(subscriber instanceof SafeSubscriber)) {        // assign to `observer` so we return the protected version        subscriber = new SafeSubscriber<T>(subscriber);    }    try {        // allow the hook to intercept and/or decorate        hook.onSubscribeStart(observable, observable.onSubscribe).call(subscriber);        return hook.onSubscribeReturn(subscriber);    } catch (Throwable e) {        ...        if (subscriber.isUnsubscribed()) {            RxJavaPluginUtils.handleException(hook.onSubscribeError(e));        } else {            // if an unhandled error occurs executing the onSubscribe we will propagate it            try {                subscriber.onError(hook.onSubscribeError(e));            } catch (Throwable e2) {                ....                throw r;            }        }        return Subscriptions.unsubscribed();    }}

省去了一些异常检查的代码，进入这个方法之后，参数subscriber就是我们的订阅者，observable就是当前已经建立好计划表的被观察者对象。在这个方法中基本的非空校验通过之后，接下来回调subscriber的onStart方法，在这里事件还没有开始执行可以做一些准备工作。然后将subscriber用一个包装者模式封装成SafeSubscriber对象，这个包装类进行了一些异常逻辑的处理。紧接着调用hook对象的onSubscribeStart方法，传人的参数为被观察者observable和它的计划表onSubscribe对象。

public <T> OnSubscribe<T> onSubscribeStart(Observable<? extends T> observableInstance, final OnSubscribe<T> onSubscribe) {    // pass through by default    return onSubscribe;}

这个方法的默认返回值为参数中的计划表对象，接下来拿到这个计划表对象onSubscribe之后，主动回调它的call方法，完成一次事件触发，同时将当前订阅者subcriber以参数的形式传入，回到第一步中的计划表对象call实现

@Overridepublic void call( Subscriber<? super String> subscriber ) {    Log.d( TAG, "OnSubscribe call: " );    subscriber.onNext( "123" );  }} );

在计划表的call方法中，subercriber.onNext方法即通知订阅者去执行它的下一步。同时在Observable.subscribe还有一些异常处理，一旦某个计划表出现异常，即会回调订阅者的onError方法，告诉订阅者订阅失败。

总结，上述简单例子是RxAndroid的基础，每一个被观察者都对应有一个计划表对象OnSubscribe。下面用图表的形式展示下这段代码的执行过程:
1.Observable.create: 创建一个被观察者对象和一个计划表OnSubscribe对象
2.Observable.subscribe: 创建一个订阅者Subscribe对象,同时触发事件

一次事件的过程为:被观察者Observable对象的计划表ObSubscribe的call方法被调用，同时在call方法中，回调订阅者Subscribe的onNext方法(观察者的一个拓展实现).最后onCompleted和onError方法有且仅有一个被回调。这是只有一层结构的被观察者和订阅者的情形。