一.正常执行流程分析
Observable.create(new Observable.OnSubscribe() {
@Override
public void call(Subscriber subscriber) {
subscriber.onNext("123456");
subscriber.onCompleted();
}
}).subscribe(new Subscriber() {
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(String string) {
Log.i("TAG","String=" + string);
}
});
这是一个简单的构建RxJava从被观察者到观察者的流程，这里我们首先还是先声明一些概念性的东西
- Observable 被观察者
- Subscriber 观察者
- OnSubscribe 从设计模式角度理解，OnSubscribe.call（）可以理解为观察者模式中被观察者用来通知观察者的notifyObservers()方法
- subscribe（） 实现观察者与被观察者订阅关系的方法
同样我们的解析流程也是从创建Observable，创建Subscriber到最后的订阅关系来进行解析
1.创建Observable（被观察者）
创建Observable通过Observable.create（）方法，我们看一下这个方法的实现
public static Observable create(OnSubscribe f) {
return new Observable(RxJavaHooks.onCreate(f));
}
我们看一下RxJavaHooks.onCreate()方法
public static Observable.OnSubscribe onCreate(Observable.OnSubscribe onSubscribe) {
Func1 f = onObservableCreate;
if (f != null) {
return f.call(onSubscribe);
}
return onSubscribe;
}
这里其实就是返回onCreate传入的OnSubscribe，也就是我们创建的OnSubscribe
至此我们做下逻辑梳理：Observable.create()方法构造了一个被观察者Observable对象，同时将new出来的OnSubscribe赋值给了该Observable的成员变量onSubscribe。
2.创建Subscriber（观察者）
创建其实很简单，我们这里简单看一下Subscriber的源码
public abstract class Subscriber implements Observer, Subscription {
private final SubscriptionList subscriptions;//订阅事件集，所有发送给当前Subscriber的事件都会保存在这里
...
protected Subscriber(Subscriber subscriber, boolean shareSubscriptions) {
this.subscriber = subscriber;
this.subscriptions = shareSubscriptions && subscriber != null ? subscriber.subscriptions : new SubscriptionList();
}
...
@Override
public final void unsubscribe() {
subscriptions.unsubscribe();
}
@Override
public final boolean isUnsubscribed() {
return subscriptions.isUnsubscribed();
}
public void onStart() {
}
...
}
Subscriber实现了Observer接口，提供了onCompleted()，onError()与onNext()，需要我们继承并进行相关操作。
Subscriber实现了Subscription接口，从而对外提供isUnsubscribed()和unsubscribe()方法。前者用于判断是否已经取消订阅；后者用于将订阅事件列表(也就是当前观察者的成员变量subscriptions)中的所有Subscription取消订阅，并且不再接受观察者Observable发送的后续事件。
3.subscribe()源码分析
部分源码如下
static Subscription subscribe(Subscriber subscriber, Observable observable) {
...
subscriber.onStart();
if (!(subscriber instanceof SafeSubscriber)) {
subscriber = new SafeSubscriber(subscriber);
}
try {
RxJavaHooks.onObservableStart(observable, observable.onSubscribe).call(subscriber);
return RxJavaHooks.onObservableReturn(subscriber);
} catch (Throwable e) {
...
return Subscriptions.unsubscribed();
}
}
上述代码中最关键的就是RxJavaHooks.onObservableStart(observable, observable.onSubscribe).call(subscriber)。这里的RxJavaHooks和之前提到的一样，RxJavaHooks.onObservableStart(observable, observable.onSubscribe)返回的正是他的第二个入参observable.onSubscribe，也就是当前observable的成员变量onSubscribe。而这个成员变量我们前面提到过，它是我们在Observable.create()的时候new出来的。
所以这段代码可以简化为onSubscribe.call(subscriber)，通过这样就建立了观察者与被观察者的联系
所以最后我们再总结一下整个流程
1.调用crate()创建一个观察者，同时创建一个OnSubscribe作为该方法的入参
2.调用subscribe()来订阅我们自己创建的观察者Subscriber
3.一旦调用subscribe()方法后就会触发执行OnSubscribe.call()
4.我们就可以在call方法调用观察者subscriber的onNext(),onCompleted(),onError()
二.操作符原理分析
我们以map操作符为例子，使用如下
Observable.create(new Observable.OnSubscribe() {
@Override
public void call(Subscriber subscriber) {
subscriber.onNext(123456);
subscriber.onCompleted();
}
}).map(new Func1() {
@Override
public String call(Integer integer) {
return "This is" + integer;
}
}).subscribe(new Subscriber() {
@Override
public void onCompleted() {}
@Override
public void onError(Throwable e) {}
@Override
public void onNext(String string) {
Log.i("TAG","String=" + string);
}
});
我们直接看map操作相关的代码部分，如下
public final Observable map(Func1 func) {
return unsafeCreate(new OnSubscribeMap(this, func));
}
public static Observable unsafeCreate(OnSubscribe f) {
return new Observable(RxJavaHooks.onCreate(f));
}
从这里我们看见，是创建了一个新的被观察者，然后这个新的被观察者与观察者建立关联，这里与前面的观察者建立的区别在于OnSubscribe成员变量的不同。
这里是一个新的OnSubscribe成员变量OnSubscribeMap，继承于OnSubscribe，代码如下：
public final class OnSubscribeMap implements OnSubscribe {
final Observable source;
final Func1 transformer;
public OnSubscribeMap(Observable source, Func1 transformer) {
this.source = source;
this.transformer = transformer;
}
@Override
public void call(final Subscriber o) {
MapSubscriber parent = new MapSubscriber(o, transformer);
o.add(parent);
source.unsafeSubscribe(parent);
}
static final class MapSubscriber extends Subscriber {
final Subscriber actual;
final Func1 mapper;
boolean done;
public MapSubscriber(Subscriber actual, Func1 mapper) {
this.actual = actual;
this.mapper = mapper;
}
@Override
public void onNext(T t) {
R result;
try {
result = mapper.call(t);
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
unsubscribe();
onError(OnErrorThrowable.addValueAsLastCause(ex, t));
return;
}
actual.onNext(result);
}
@Override
public void onError(Throwable e) {
...
actual.onError(e);
}
@Override
public void onCompleted() {
...
actual.onCompleted();
}
@Override
public void setProducer(Producer p) {
actual.setProducer(p);
}
}
}
我们看下OnSubscribeMap构造函数的传入的两个变量，一个是之前创建的Observable（被观察者），另外一个是我们新操作的Func1函数。
然后在调用subscribe()方法后就会触发执行OnSubscribeMap.call()方法，我们仔细看一下这个方法，
MapSubscriber parent = new MapSubscriber(o, transformer);
o.add(parent);
source.unsafeSubscribe(parent);
首先是通过创建了观察者o和转换函数Func1构造了一个新的观察者MapSubscriber，接下来最后调用了source也就是的unsafeSubscribe()方法，而这个source通过前后关系，我们可以知道是之前创建的Observable（被观察者）。
接下来看一下unsafeSubscribe函数
public final Subscription unsafeSubscribe(Subscriber subscriber) {
try {
// new Subscriber so onStart it
subscriber.onStart();
// allow the hook to intercept and/or decorate
RxJavaHooks.onObservableStart(this, onSubscribe).call(subscriber);
return RxJavaHooks.onObservableReturn(subscriber);
} catch (Throwable e) {
...
return Subscriptions.unsubscribed();
}
}
这里是不是很熟悉，和前面说过的一样，也就是调用了onSubscribe.call（）方法，注意这里的onSubscribe是最早创建的Observable（被观察者）的onSubscribe，而subscriber则是新构建的观察者MapSubscriber。
所有当onSubscribe.call()方法调用后，我们看下调用的方法，如下
subscriber.onNext(123456);
subscriber.onCompleted();
所有这里其实是调用MapSubscriber的onNext方法与onCompleted方法，我们分析下onNext方法，如下
@Override
public void onNext(T t) {
R result;
try {
result = mapper.call(t);
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
unsubscribe();
onError(OnErrorThrowable.addValueAsLastCause(ex, t));
return;
}
actual.onNext(result);
}
可以看到这里首先做了预处理mapper.call(t)，这里的mapper就是我们重写的Func1中的方法。
所有其实我们执行的顺序是
1.MapSubscriber.onNext(123456)。
2.map中的call方法进行处理。
3.执行原始的观察者的onNext（T）方法。
所以最后我们再总结一下整个流程
1.调用crate()创建一个观察者A，同时创建一个OnSubscribe作为该方法的入参
2.调用map()创建一个观察者B，同时创建一个OnSubscribeMap作为该方法入参，创建OnSubscribeMap传入观察者A与转换函数Func1
3.调用subscribe()来订阅我们自己创建的观察者Subscriber
4.一旦调用subscribe()方法后就会触发执行MapOnSubscribe.call()，这个方法内创建新的观察者MapSubscriber，通过观察者o和转换函数Func1构建
5.MapOnSubscribe.call()调用了unsafeSubscribe函数，这里面调用了onSubscribe.call（）方法，这里的onSubscribe是最早创建的Observable（被观察者）的onSubscribe，而subscriber则是新构建的观察者MapSubscriber。
6.接下来就是执行相关的传递工作，MapSubscriber.onNext方法，map中的call方法进行处理，执行原始的观察者的onNext（T）方法。
至此结束。
三.线程调到分析
RxJava其中一个很重要的特性就是对于线程调度想对来说比较容易，可以很方便的通过subscribeOn()和observeOn()来指定数据流的每一部分运行在哪个线程。
subscribeOn()指定了处理Observable（被观察者）的全部的过程(包括发射数据和通知)的线程。
observeOn()指定了Subscriber（观察者）的onNext(), onError()和onCompleted()执行的线程。
我们首先看一下线程调度的代码
Observable.create(new Observable.OnSubscribe() {
@Override
public void call(Subscriber subscriber) {
subscriber.onNext(123456);
subscriber.onCompleted();
}
}).subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Subscriber() {
@Override
public void onCompleted() {}
@Override
public void onError(Throwable e) {}
@Override
public void onNext(String string) {
Log.i("TAG","String=" + string);
}
});
1.subscribeOn()源码分析
经过调用，代码如下
public final Observable subscribeOn(Scheduler scheduler, boolean requestOn) {
if (this instanceof ScalarSynchronousObservable) {
return ((ScalarSynchronousObservable)this).scalarScheduleOn(scheduler);
}
return unsafeCreate(new OperatorSubscribeOn(this, scheduler, requestOn));
}
是不是看到了熟悉的一幕，接下来我们看下OperatorSubscribeOn这个类
public final class OperatorSubscribeOn implements OnSubscribe {
final Scheduler scheduler;
final Observable source;
final boolean requestOn;
public OperatorSubscribeOn(Observable source, Scheduler scheduler, boolean requestOn) {
this.scheduler = scheduler;
this.source = source;
this.requestOn = requestOn;
}
@Override
public void call(final Subscriber subscriber) {
final Worker inner = scheduler.createWorker();
SubscribeOnSubscriber parent = new SubscribeOnSubscriber(subscriber, requestOn, inner, source);
subscriber.add(parent);
subscriber.add(inner);
inner.schedule(parent);
}
static final class SubscribeOnSubscriber extends Subscriber implements Action0 {
...
}
}
所有在调用subscribe()方法后就会触发执行OperatorSubscribeOn.call()方法，这里调用了scheduler的createWorker方法
这里的scheduler是我们定义传进来的，即Schedulers.io()
public static Scheduler io() {
return RxJavaHooks.onIOScheduler(getInstance().ioScheduler);
}
private Schedulers() {
...
Scheduler io = hook.getIOScheduler();
if (io != null) {
ioScheduler = io;
} else {
ioScheduler = RxJavaSchedulersHook.createIoScheduler();
}
...
}
经过调用，发现我们实现的Schedulers是CachedThreadScheduler，接下来我们看下createWorker方法，如下
public Worker createWorker() {
return new EventLoopWorker(pool.get());
}
这里返回了一个新的EventLoopWorker对象，而这个EventLoopWorker是CachedThreadScheduler的内部类。
接下来回去看call方法，我们会发现执行了EventLoopWorker的schedule方法如下
@Override
public Subscription schedule(final Action0 action, long delayTime, TimeUnit unit) {
if (innerSubscription.isUnsubscribed()) {
// don't schedule, we are unsubscribed
return Subscriptions.unsubscribed();
}
ScheduledAction s = threadWorker.scheduleActual(new Action0() {
@Override
public void call() {
if (isUnsubscribed()) {
return;
}
action.call();
}
}, delayTime, unit);
innerSubscription.add(s);
s.addParent(innerSubscription);
return s;
}
这里执行了scheduleActual方法，我们看一下这个方法的实现
public ScheduledAction scheduleActual(final Action0 action, long delayTime, TimeUnit unit) {
Action0 decoratedAction = RxJavaHooks.onScheduledAction(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;
}
这个方法主要是将传入的Action0包装成ScheduledAction，然后线程池运行这个ScheduledAction，那么这个ScheduledAction肯定是继承Runable或者Callable的
找到ScheduledAction的run方法如下
@Override
public void run() {
...
action.call();
...
}
这里调用的传入Action0的call方法，我们看下定义的Action0的call方法，这个方法是调用了schedule方法时候传入Action0的call方法
通过查看，我们知道这个Action0即是SubscribeOnSubscriber，接下来看一个这个SubscribeOnSubscriber的call方法
@Override
public void call() {
Observable src = source;
source = null;
t = Thread.currentThread();
src.unsafeSubscribe(this);
}
这里的source是之前创建的Observable（被观察者），接下来调用unsafeSubscribe方法，如下
public final Subscription unsafeSubscribe(Subscriber subscriber) {
try {
// new Subscriber so onStart it
subscriber.onStart();
// allow the hook to intercept and/or decorate
RxJavaHooks.onObservableStart(this, onSubscribe).call(subscriber);
return RxJavaHooks.onObservableReturn(subscriber);
} catch (Throwable e) {
...
return Subscriptions.unsubscribed();
}
}
和前面操作符一致，这里的onSubscribe是最早创建的Observable（被观察者）的onSubscribe，而subscriber则是新构建的观察者SubscribeOnSubscriber。
所以这时候onSubscribe的call操作其实已经是在异步的线程中执行了。