RxJava解析

RxJava解析

RxJava的核心思想是通过链式调用使得异步代码调用变得简洁方便。看了网上其他一些介绍RxJava调用的文章时，对其使用和实现原理还是理解不到位，最后通过分析源码的调用弄明白了链式调用和线程切换的实现方式。本文章的内容分为三个部分：

一、基本的调用方式
二、链式调用
三、线程切换

---

一、基本的调用方式

链式调用的实现：之所以能实现链式调用，是因为每个函数返回的对象都是同一个类型的对象，一次最简单的RxJava异步调用如下所示：：

Observable.create(new Observable.OnSubscribe<String>() {
    @Override
    public void call(Subscriber<? super String> subscriber) {
        subscriber.onNext("hello world!");
        subscriber.onCompleted();
    }
}).subscribe(new Subscriber<String>() {
    @Override
    public void onCompleted() {
        Log.d(TAG, "Completed!");
    }

    @Override
    public void onError(Throwable e) {
        Log.d(TAG, "Error");
    }

    @Override
    public void onNext(String s) {
        Log.d(TAG, "Item: " + s);
    }
});

这个函数有两步构成：
1.Observable.create很好理解，即创建了一个Observable对象，且给该对象的属性OnSubscribe赋值为新建的OnSubscribe对象，在这一时刻什么都没有发生，只是创建了Observable对象。
2.继续调用subscribe方法，看看这个方法的核心代码实现（之后的代码都为省略后的代码）：

public Subscription subscribe(Subscriber subscriber, Observable observable) {
    subscriber.onStart();
    onSubscribe.call(subscriber);
    return subscriber;
} 

其实就是回调了该Observable中OnSubscribe的call方法，而在call方法中又回调了订阅者Subscriber的onNext方法，完成对于订阅者的回调。

---

二、链式调用

看看下面这个列子：

Observable.create(new Observable.OnSubscribe<String>() {
    @Override
    public void call(Subscriber<? super String> subscriber) {
        subscriber.onNext("hello world!");
        subscriber.onCompleted();
    }
}).map(new Func1<String, Integer>() {
    public Integer call(String str) {
        return str.length();
    }
}).subscribe(new Subscriber<Integer>() {
    @Override
    public void onCompleted() {
        Log.d(TAG, "Completed!");
    }
    @Override
    public void onError(Throwable e) {
        Log.d(TAG, "Error");
    }
    @Override
    public void onNext(Integer s) {
        Log.d(TAG, "Item: " + s);
    }
}); 

这个例子与上面例子的唯一区别就是在中间调用了一次map操作，把最初泛型为String的Observable1对象转换成了泛型为Integer的Observable2对象，然后又调用了Observable2对象的subscribe方法。那么这里的核心就是map函数，而map函数的核心是lift函数，该函数在所有中间过程产生Observable的过程中基本上都会被调用，那么看看该函数在该代码例子中的核心实现：

public final  Observable<Integer> lift(final Operator<Integer, String> operator) {
    return new Observable<Integer>(new OnSubscribe<Integer>() {
        @Override
        public void call(Subscriber<Integer> o) {
                Subscriber<String> st = operator.call(o);  // 1
                st.onStart();  // 2
                onSubscribe.call(st);  // 3
        }
    });
} 

可以看出该函数确实创建了一个新的Observable2对象和该对象的OnSubscribe2对象，当调用该对象的subscribe方法时，就会调用该对象的OnSubscribe2对象的call方法，我们来看看该call方法调用设计的三行代码：

1.根据参数operator创建了一个订阅者Subscriber0；
2.调用该Subscriber2的onStart方法；
3.因为lift方法是由Observable1对象调用的，因此这里的onSubscribe是Observable1的onSbuscribe2；说明第一步创建的订阅者是Subscriber0是Observable1的订阅者，是通过Observable1的onSubscribe1调用了这个subscribe0的onNext方法，这里我们就需要看一看，这个订阅者subscribe0做了什么，再看看operator.call的内容：

public Subscriber<String> call(final Subscriber<Integer> o) {
    return new Subscriber<T>(o) {
        @Override
        public void onNext(T t) {
             o.onNext(transformer.call(t));
        }

    };
}

这里的transformer是什么？就是map时传入的Func1对象，它会把onSubscribe1传入的string参数转换为integer，然后再调用参数subscriber2（就是最后一个subscriber调用传入的订阅者）的onNext方法。最终map的调用可以这样理解：

1.为第一个客户端代码create的Observable1对象产生一个subscriber1对象，该subscriber1对象封装了map中的Func1方法；当最终订阅的时候，Observable1的订阅方法完成后，它的onSubscribe1会调用该subscriber1的onNext方法，即Func1的call方法，把string转为integer；

2.同时会产生一个新的Observable2对象，并创建该对象的Onsubscribe2对象，Observable2对象的订阅者为最后subscriber的subscriber2对象，当该Observable2调用subscriber的时候，会调用onSubscribe2的call方法，该方法会先调用产生Observable2对象的Observable1对象的订阅者的回调，即Func1，然后再调用Observable2对象的subscriber2对象的onNext方法。即这条链上的每个Observable2对象订阅时，都会先回调产生它的上一个Observable1对象的订阅者的回调方法，即产生Observable2时为Observalbe1添加的订阅者的回调。即map中的Func1是对create产生的Observable1的观察回调。

---

二、链式调用

（一）subscribeOn切换线程

让我们先来看看下面的一段代码：

 Observable.create(new Observable.OnSubscribe<String>() {
    @Override
    public void call(Subscriber<? super String> subscriber) {
        subscriber.onNext("hello world!");
        subscriber.onCompleted();
    }
})
.subscribeOn(Schedulers.newThread())
.subscribe(new Subscriber<String>() {
    @Override
    public void onCompleted() {
        Log.d(TAG, "Completed!");
    }
    @Override
    public void onError(Throwable e) {
        Log.d(TAG, "Error");
    }
    @Override
    public void onNext(String s) {
        Log.d(TAG, "Item: " + s);
    }
});

这段代码的作用是将create的Observable1的OnSubscribe的call方法放到下面subscribeOn指定的新线程中执行。看看subscribeOn的调用：

 public final Observable<String> subscribeOn(Scheduler scheduler) {
    return nest().lift(new OperatorSubscribeOn<String>(scheduler));
}

该函数先调用nest函数，此函数也创建了一个新的Observable对象：

 public final Observable<Observable<String>> nest() {
    return ScalarSynchronousObservable.create(this);
}

可以看到该函数产生了一个新的Observable，并把其泛型类型变为了

 public static final <Observable<String>> ScalarSynchronousObservable<Observable<String>> create(Observable<String> t) {
    return new ScalarSynchronousObservable<Observable<String>>(t);
}

private final Observable<String> t;

protected ScalarSynchronousObservable(final Observable<String> t) {
    super(new OnSubscribe<Observable<String>>() {
        @Override
        public void call(Subscriber<Observable<String>> s) {
            s.onNext(t);
            s.onCompleted();
        }

    });
    this.t = t;
}

在ScalarSynchronousObservable的OnSubscribe的call方法中，它没有像之前lift产生的Observable一样，回调产生它的Observable的OnSubscribe的call方法，而是把产生它的Observable交给了它的Subscriber去处理。而该ScalarSynchronousObservable的Subscriber是通过nest之后的lift操作所产生的Subscriber去处理。因此根据subscriberOn的功能可以判断，该lift产生的Subscriber的onNext方法，应该是为第一个创建的Observable创建一个String类型的subscriber，并判断当前的线程是否是需要切换的线程，如果是则执行参数Observable（即创建的第一个Observable对象）的onSubscribe的call回调方法，如果不是，则将该操作加入执行线程池的任务队列，等待该线程池调度执行。

先看看lift产生的Observable对象，跟之前map的lift是同一个函数：

public final  Observable<String> lift(final Operator<String, Observable<String>> operator) {
    return new Observable<String>(new OnSubscribe<String>() {
        @Override
        public void call(Subscriber<String> o) {
                Subscriber<String> st = operator.call(o);  // 1
                st.onStart();  // 2
                onSubscribe.call(st);  // 3
        }
    });
} 

因此，这里产生的subscriber是关键，在ScalarSynchronousObservable的onSubscribe的call方法中，它会把第一个Observable当做参数去处理，我们来看一下这个subscriber的创建，它是由OperatorSubscribeOn的call方法创建的：

return new Subscriber<Observable<T>>(subscriber) {
    @Override
    public void onCompleted() {
    }

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

    @Override
    public void onNext(final Observable<T> o) {
        inner.schedule(new Action0() {
            @Override
            public void call() {
                final Thread t = Thread.currentThread();
                o.unsafeSubscribe(new Subscriber<T>(subscriber) {

                    @Override
                    public void onCompleted() {
                        subscriber.onCompleted();
                    }

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

                    @Override
                    public void onNext(T t) {
                        subscriber.onNext(t);
                    }

                    @Override
                    public void setProducer(final Producer producer) {
                        subscriber.setProducer(new Producer() {

                            @Override
                            public void request(final long n) {
                                if (Thread.currentThread() == t) {
                                    producer.request(n);
                                } else {
                                    inner.schedule(new Action0() {
                                        @Override
                                        public void call() {
                                            producer.request(n);
                                        }
                                    });
                                }
                            }

                        });
                    }

                });
            }
        });
    }

}; 

可以看出来，这个订阅方法的onNext中确实是通过创建的inner进行线程调度，然后给最初的Observable对象创建了subscriber对象，以便形成完整的调用链。因此，subscribeOn方法，使得该Observable之前的Observable的订阅和回调方法在该方法制定的线程上执行。

（二）observeOn方法

Observable.create(new Observable.OnSubscribe<String>() {
    @Override
    public void call(Subscriber<? super String> subscriber) {
        subscriber.onNext("hello world!");
        subscriber.onCompleted();
    }
})
.observeOn(Schedulers.io())
.subscribe(new Subscriber<String>() {
    @Override
    public void onCompleted() {
        Log.d(TAG, "Completed!");
    }
    @Override
    public void onError(Throwable e) {
        Log.d(TAG, "Error");
    }
    @Override
    public void onNext(String s) {
        Log.d(TAG, "Item: " + s);
    }
}); 

observeOn方法也是切换线程的操作，调用该方法后，其之后执行的回调方法会在该方法制定的线程上操作。因此，我们猜想observeOn是直接进行了lift操作进行线程变换，然后继续往下调用，是否如此呢，我们来看看observeOn的实现：

public final Observable<String> observeOn(Scheduler scheduler) {
    return lift(new OperatorObserveOn<String>(scheduler));
}

看看OperatorObserveOn的call方法：

public Subscriber<String> call(Subscriber<String> child) {
    if (scheduler instanceof ImmediateScheduler) {
        return child;
    } else if (scheduler instanceof TrampolineScheduler) {
        return child;
    } else {
        ObserveOnSubscriber<String> parent = new ObserveOnSubscriber<String>(scheduler, child);
        parent.init();
        return parent;
    }
} 

前两个if-else判断，应该是判断当前的线程如果与指定的线程是同一个，则直接调用最终subscriber的onNext方法，不进行线程切换，如果需要切换线程，则创建一个ObserveOnSubscriber对象，在该对象的onNext方法中，会在指定的线程中调度执行其child（即最终传入的subscriber）的回调方法。

总结，对于subscribeOn方法，第一个出现的subscribeOn方法制定的线程，会制定它调用之前的（若它之前还有observeOn方法，会影响第一个出现的observeOn方法之前的）订阅和所有回调方法的执行线程，而observeOn方法会影响它之后出现的回调方法的执行线程。

最后再举一个例子说明，对于下面的代码调用：

Observable.create(new Observable.OnSubscribe<String>() {
    @Override
    public void call(Subscriber<? super String> subscriber) {
        Log.i(TAG, "0 CURRENT THREAD = " + Thread.currentThread().getName());
        subscriber.onNext("hello world!");
        subscriber.onCompleted();
    }
})
.observeOn(Schedulers.io())
.map(new Func1<String, String>() {
    @Override
    public String call(String s) {
        Log.i(TAG, "1 CURRENT THREAD = " + Thread.currentThread().getName());
        return s;
    }
})
.subscribeOn(Schedulers.computation())
.observeOn(Schedulers.newThread())
.subscribe(new Subscriber<String>() {
    @Override
    public void onCompleted() {
        Log.d(TAG, "Completed!");
    }
    @Override
    public void onError(Throwable e) {
        Log.d(TAG, "Error");
    }
    @Override
    public void onNext(String s) {
        Log.i(TAG, "2 CURRENT THREAD = " + Thread.currentThread().getName());
        Log.d(TAG, "Item: " + s);
    }
}); 

0处线程应该是在computation线程，1处线程应该是在io线程，2处线程应该是在new线程，执行结果如下：

• 关于 RxJava 用法，参考 这儿.

---