RxJava的使用解析（一）
RxJava越来越受到开发者的青睐，主要是因为他方便的线程切换以及简洁的流式调用，可以使用RxJava的操作符组合使用完成很多复杂的逻辑。让你用了之后，完全离不开它。本文跳过RxJava的使用，分析内部的调用源码，让你知其然，知其所以然。下面的源码解析是基于RxJava1.x.x版本的，后续会推出RxJava2的介绍文章。
流程分析
RxJava采用的是发布-订阅的观察者模式，它是怎么订阅的呢？
Observable.create(new Observable.OnSubscrible(){
@Override
public void call(Subscrible subscriber){
subscriber.onNext(88);
}
}).subscribe(new Subscriber(){
public void onCompleted(){
}
public void onNext(Integer i){
}
public void onError(Throwable e){
}
})
看create()方法
public static Observable create(OnSubscribe f) {
return new Observable(hook.onCreate(f));
}
public OnSubscribe onCreate(OnSubscribe f) {
return f;
}
protected Observable(OnSubscribe f) {
this.onSubscribe = f;
}
hook相当于是一个代理对象，起到装饰和拦截作用，hook.create返回的还是参数f，将f赋给Observable的onSubscribe成员变量
看subscriber()订阅方法：
public final Subscription subscribe(Subscriber subscriber) {
return Observable.subscribe(subscriber, this);
}
private static Subscription subscribe(Subscriber subscriber, Observable observable) {
...
//空方法,
subscriber.onStart();
if (!(subscriber instanceof SafeSubscriber)) {
// 将subscriber包装成safeSubscriber，以确保onError和onCompleted只有一个被调用。
subscriber = new SafeSubscriber(subscriber);
}
try {
//这句代码是关键，onSubscribeStart方法返回的就是前面new出来的onSubscribe对象，接着调用call方法。
hook.onSubscribeStart(observable, observable.onSubscribe).call(subscriber);
return hook.onSubscribeReturn(subscriber);
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
// 当call方法出现异常时会回调到onError中
try {
subscriber.onError(hook.onSubscribeError(e));
} catch (Throwable e2) {
Exceptions.throwIfFatal(e2);
RuntimeException r = new RuntimeException("Error occurred attempting to subscribe [" + e.getMessage() + "] and then again while trying to pass to onError.", e2);
hook.onSubscribeError(r);
throw r;
}
return Subscriptions.unsubscribed();
}
}
返回的是Subscription对象，用于解除订阅。可以看出，call方法中的subscriber就是下方new出来的Subscriber对象。Observable是被观察者，Subscriber是观察者，被观察者Observable订阅观察者Subscriber对象。
Map操作符分析
示例：
Observable.create(new Observable.OnSubscrible(){
@Override
public void call(Subscrible subscriber){
subscriber.onNext(88);
}
}).map(new Func1(){
@override
public String call(Integer i){
return "transform"+i;
}
})
.subscribe(new Subscriber(){
public void onCompleted(){
}
public void onNext(String s){
Log.d(TAG,s);
}
public void onError(Throwable e){
}
});
看map方法
public final Observable map(Func1 func) {
return lift(new OperatorMap(func));
}
//lift方法
public final Observable lift(final Operator operator) {
return new Observable(new OnSubscribe() {
@Override
public void call(Subscriber o) {
try {
//hook.onLift(operator)返回operator
Subscriber st = hook.onLift(operator).call(o);
try {
st.onStart();
//调用上层的call方法
onSubscribe.call(st);
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
st.onError(e);
}
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
o.onError(e);
}
}
});
}
operator就是,OperatorMap，构造函数将map的转换函数transformer传入，调用其call方法
public Subscriber call(final Subscriber o) {
return new Subscriber(o) {
@Override
public void onCompleted() {
o.onCompleted();
}
@Override
public void onError(Throwable e) {
o.onError(e);
}
@Override
public void onNext(T t) {
try {
//转换的结果包裹在onNext参数中，
o.onNext(transformer.call(t));
} catch (Throwable e) {
Exceptions.throwOrReport(e, this, t);
}
}
};
}
这里的参数o是哪里的呢，看上文可以知道，在subscribe()订阅方法，会调用lift方法中new出来的Observable的call方法，这个call方法又会调用上层的nsubscriber.call()方法，层层调用。下流的subscriber对象传给OperatorMap的call方法参数中，new出来新的Subscriber又传给onSubscriber的参数里，一图胜千言。
线程调度原理分析
示例：
Observable.create(new Observable.OnSubscrible(){
@Override
public void call(Subscrible subscriber){
subscriber.onNext(88);
}
}).map(new Func1(){
@override
public String call(Integer i){
return "transform"+i;
}
}).SubscribeOn(Schedules.io())
.ObservableOn(AndroidSchedule.MainThread()).
.subscribe(new Subscriber(){
public void onCompleted(){
}
public void onNext(String s){
Log.d(TAG,s);
}
public void onError(Throwable e){
}
});
分析SubscribeOn(Schedules.io())
public final Observable subscribeOn(Scheduler scheduler) {
if (this instanceof ScalarSynchronousObservable) {
return ((ScalarSynchronousObservable)this).scalarScheduleOn(scheduler);
}
return create(new OperatorSubscribeOn(this, scheduler));
}
OperatorSubscribeOn继承OnSubscribe，看下call方法,
public void call(final Subscriber subscriber) {
final Worker inner = scheduler.createWorker();
subscriber.add(inner);
inner.schedule(new Action0() {
@Override
public void call() {
final Thread t = Thread.currentThread();
Subscriber s = new Subscriber(subscriber) {
@Override
public void onNext(T t) {
subscriber.onNext(t);
}
@Override
public void onError(Throwable e) {
try {
subscriber.onError(e);
} finally {
inner.unsubscribe();
}
}
@Override
public void onCompleted() {
try {
subscriber.onCompleted();
} finally {
inner.unsubscribe();
}
}
@Override
public void setProducer(final Producer p) {
subscriber.setProducer(new Producer() {
@Override
public void request(final long n) {
if (t == Thread.currentThread()) {
p.request(n);
} else {
inner.schedule(new Action0() {
@Override
public void call() {
p.request(n);
}
});
}
}
});
}
};
source.unsafeSubscribe(s);
}
});
}
scheduler.createWorker(),scheduler的最终实现类是谁呢，顺着io线程找
public Worker createWorker() {
return new EventLoopWorker(pool.get());
}
pool的类是CachedWorkerPool，它是一个ScheduledThreadPool，里面只有一个核心线程，当线程工厂中有新的线程时，就会执行runable中run方法。
ThreadWorker get() {
if (allWorkers.isUnsubscribed()) {
return SHUTDOWN_THREADWORKER;
}
while (!expiringWorkerQueue.isEmpty()) {
ThreadWorker threadWorker = expiringWorkerQueue.poll();
if (threadWorker != null) {
return threadWorker;
}
}
// 没有缓存就创建一个新的ThreadWork
ThreadWorker w = new ThreadWorker(WORKER_THREAD_FACTORY);
allWorkers.add(w);
return w;
}
先从队列取，没有才new一个新的Thread。接着调用Schedule方法
public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) {
if (innerSubscription.isUnsubscribed()) {
// 解除订阅
return Subscriptions.unsubscribed();
}
ScheduledAction s = threadWorker.scheduleActual(action, delayTime, unit);
innerSubscription.add(s);
s.addParent(innerSubscription);
return s;
}
//NewThreadWork
public ScheduledAction scheduleActual(final Action0 action, long delayTime, TimeUnit unit) {
Action0 decoratedAction = schedulersHook.onSchedule(action);
ScheduledAction run = new ScheduledAction(decoratedAction);
Future f;
if (delayTime <= 0) {
f = executor.submit(run);
} else {
f = executor.schedule(run, delayTime, unit);
}
run.add(f);
return run;
}
将action包装成ScheduledAction，ScheduledAction继承Runable接口，在run方法中调用action.call()方法。executeor是Executors.newScheduledThreadPool(1, threadFactory)线程池。提交执行runable对象。
再看source.unsafeSubscribe(s)；
public final Subscription unsafeSubscribe(Subscriber subscriber) {
try {
// subscriber是上面重新new的Subscriber对象
subscriber.onStart();
// 调用create()方法new新的Observable对象的onSubscribe的call方法
hook.onSubscribeStart(this, onSubscribe).call(subscriber);
return hook.onSubscribeReturn(subscriber);
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
try {
subscriber.onError(hook.onSubscribeError(e));
} catch (Throwable e2) {
Exceptions.throwIfFatal(e2);
RuntimeException r = new RuntimeException("Error occurred attempting to subscribe [" + e.getMessage() + "] and then again while trying to pass to onError.", e2);
hook.onSubscribeError(r);
throw r;
}
//返回subscription对象
return Subscriptions.unsubscribed();
}
}
ObservableOn(AndroidSchedulers.mainThread())方法原理分析
public final Observable observeOn(Scheduler scheduler) {
if (this instanceof ScalarSynchronousObservable) {
return ((ScalarSynchronousObservable)this).scalarScheduleOn(scheduler);
}
return lift(new OperatorObserveOn(scheduler, false));
}
lift()方法上面已经分析了，看OperatorObserveOn里的call方法
public Subscriber call(Subscriber child) {
if (scheduler instanceof ImmediateScheduler) {
// 如果是ImmediateScheduler，直接执行
return child;
} else if (scheduler instanceof TrampolineScheduler) {
// 如果是TrampolineScheduler，直接执行
return child;
} else {
ObserveOnSubscriber parent = new ObserveOnSubscriber(scheduler, child, delayError);
parent.init();
return parent;
}
}
将child包装成ObserveOnSubscribe对象，继承自Subscriber父类,执行init()函数
public void onNext(final T t) {
if (isUnsubscribed() || finished) {
return;
}
if (!queue.offer(on.next(t))) {
onError(new MissingBackpressureException());
return;
}
schedule();
}
@Override
public void onCompleted() {
if (isUnsubscribed() || finished) {
return;
}
finished = true;
schedule();
}
public void onError(final Throwable e) {
if (isUnsubscribed() || finished) {
RxJavaPlugins.getInstance().getErrorHandler().handleError(e);
return;
}
error = e;
finished = true;
schedule();
}
//
protected void schedule() {
if (counter.getAndIncrement() == 0) {
recursiveScheduler.schedule(this);
}
}
可以看到，每个方法里都加了schedule()方法，相当于将下游的subscribe方法移步到这个线程中，recursiceScheduler是mainThread线程createWork()产生的，看下mainThread.schedule()函数
private static final Scheduler MAIN_THREAD_SCHEDULER =
new HandlerScheduler(new Handler(Looper.getMainLooper()));
//HandlerScheduler类
@Override
public Worker createWorker() {
return new HandlerWorker(handler);
}
//HandlerWorker类
public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) {
if (compositeSubscription.isUnsubscribed()) {
return Subscriptions.unsubscribed();
}
action = RxAndroidPlugins.getInstance().getSchedulersHook().onSchedule(action);
final ScheduledAction scheduledAction = new ScheduledAction(action);
scheduledAction.addParent(compositeSubscription);
compositeSubscription.add(scheduledAction);
//关键代码
handler.postDelayed(scheduledAction, unit.toMillis(delayTime));
scheduledAction.add(Subscriptions.create(new Action0() {
@Override
public void call() {
handler.removeCallbacks(scheduledAction);
}
}));
return scheduledAction;
}
初始化一个HandlerScheduler，handler关联主线程的Looper，看schedule方法，还是将action包装成ScheduleAction对象，它是一个runnable对象，在run()方法中执行action.call()方法，通过主线程handler.postDelayed()将线程切换到主线程中。还是用一张图来表示：
总结：
每一个操作符都会new一个新的Observable对象，Observable对象包含了一个逻辑处理的OnSubscriber对象，在调用subscribe()函数时，会调用最近的Observable的call()方法，call()方法又会调用上层的OnSubscriber.call()方法，依次层层向上调用，一直到最上层的call方法，执行onNext(),onCompleted()和onError()方法。
图片参考链接：RxJava系列6(从微观角度解读RxJava源码