RxJava 源码解读
一直以来在网上看到关于RxJava的使用博客都称赞RxJava使用起来非常简洁，即使业务逻辑非常复杂，它依然能够保持简洁。于是在个人项目也添加了RxJava和RxAndroid.秉着知其然知其所以然的态度，跟着调用方法一探其源码，
首选是调用方法。这个方法是获取手机里面的所有音乐文件信息，并且返回给回调者，并且这里的ObservableOnSubscribe
public void sortMp3InfosByTitleByRx(BaseObserver> receiver)
Observable.create(new ObservableOnSubscribe>() {
@Override
public void subscribe(ObservableEmitter> observableEmitter) throws Exception {
MusicInfoDao dao=daoSession.getMusicInfoDao();
DebugLog.d("subscribe:"+Thread.currentThread().getName());
List list=dao.queryBuilder().orderAsc(com.music.bean.MusicInfoDao.Properties.TitleKey).list();
if (list.isEmpty()){
DebugLog.d("本地数据没有，去手机多媒体数据库查询");
list.addAll(MusicModel.getInstance().sortMp3InfosByTitle(MusicApplication.getInstance()));
}else{
DebugLog.d("从本地数据库获取 ");
MusicModel.getInstance().getMusicList().addAll(list);
}
musicInfoList.addAll(list);
observableEmitter.onNext(list);
observableEmitter.onComplete();
}
}).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).subscribe(receiver);
回调者封装了一个BaseObserver，因为有时候你只需要其中某一个回调就够了，
public class BaseObserver implements Observer {
@Override
public void onSubscribe(Disposable disposable) {
DebugLog.d("onSubscribe："+disposable.toString());
DebugLog.d(Thread.currentThread().getName());
}
@Override
public void onNext(T t) {
DebugLog.d("onNext");
DebugLog.d(Thread.currentThread().getName());
}
@Override
public void onError(Throwable throwable) {
DebugLog.d("onError");
}
@Override
public void onComplete() {
DebugLog.d("onComplete");
DebugLog.d(Thread.currentThread().getName());
}
}
receiver 是一个BaseObserver子类
其打印如下，正如所想，获取数据在子线程中，回调给调用者回到了主线程
那问题来了，这么几行代码如何切换线程？好像我们在获取数据的时候回调了onNext方法和onComplete方法，怎么获取数据的时候是在子线程，而真正给回调者的onNext方法和onComplete方法怎么又到主线程了？注意到说的是真正onNext方法和onComplete方法，而不是我们在获取数据的时候调用了onNext和onComplete。
这些都将在我们查看源码后一一知晓,刚开始第一遍看源码后，就好像陷入迷雾森林找不到方法一样，这种感觉是上次看startActivity一样的感觉，但是后面在反复从头查看并且做标记之后，看到后面不解在回过头看，然后连起来解读，顿时看透其中原理，简直有种酣畅淋漓之感，并且感叹写出这个代码人之牛逼哄哄。
下面解读的是基本的用法的源码，当然还有高级的用法，后面有时间再查看。
create方法
Observable.java
public static Observable create(ObservableOnSubscribe source) {
ObjectHelper.requireNonNull(source, "source is null");
return RxJavaPlugins.onAssembly(new ObservableCreate(source));
}
create方法传入的是我们的创建的ObservableOnSubscribe对象，并且在subscribe方法里面有我们的业务逻辑，create方法里面把我们创建的ObservableOnSubscribe对象包装到ObservableCreate对象
ObservableOnSubscribe是Observable的子类，并且ObservableCreate也是Observable的子类 这个也比较重要，后面我们分析完再来说明。
public final class ObservableCreate extends Observable {
final ObservableOnSubscribe source;
public ObservableCreate(ObservableOnSubscribe source) {
this.source = source;
}
可以看到里面有个source属性就是创建对象传入的参数，后面的依然类似，创建对象是传入的参数大都赋值到对象里面的souce
RxJavaPlugins onAssembly方法
public static Observable onAssembly(@NonNull Observable source) {
Function f = onObservableAssembly;
return f != null?(Observable)apply(f, source):source;
}
onObservableAssembly是调用setOnObservableAssembly方法设置的
public static void setOnObservableAssembly(@Nullable Function onObservableAssembly) {
if(lockdown) {
throw new IllegalStateException("Plugins can't be changed anymore");
} else {
onObservableAssembly = onObservableAssembly;
}
}
我们没有调用这个方法因此这个对象为Null
public static Observable create(ObservableOnSubscribe source) {
ObjectHelper.requireNonNull(source, "source is null");
return RxJavaPlugins.onAssembly(new ObservableCreate(source));
}
RxJavaPlugins onAssembly方法 返回的就是ObservableCreate对象
基本上RxJavaPlugins onAssembly方法返回的对象就是传入的对象
执行完create方法后返回的是ObservableCreate对象,里面的source就是我们创建的ObservableOnSubscribe对象
subscribeOn方法
2 create之后就是subscribeOn，因为我想我的业务逻辑运行在子线程中，因此调用了subscribeOn(Schedulers.io())方法。
查看subscribeOn方法,此方法传入一个Scheduler对象
public final Observable subscribeOn(Scheduler scheduler) {
ObjectHelper.requireNonNull(scheduler, "scheduler is null");
return RxJavaPlugins.onAssembly(new ObservableSubscribeOn(this, scheduler));
}
ObservableSubscribeOn构造器把当前对象和我们创建的Schedulers.io()对象也传入进去，猜想这个应该就是根据我们设置的线程，在我们设置的线程里面执行我们的方法，ObservableSubscribeOn类继承了AbstractObservableWithUpstream类，而AbstractObservableWithUpstream类继承Observable类
public ObservableSubscribeOn(ObservableSource source, Scheduler scheduler) {
super(source);
this.scheduler = scheduler;
}
也就是说ObservableSubscribeOn也是Observable的子类
执行完subscribeOn方法后返回的是ObservableSubscribeOn对象,里面的source是前面的ObservableCreate对象，scheduler是Schedulers.io()的,
observeOn方法
由于我们想要最终回调到主线程中，因此调用了observeOn(AndroidSchedulers.mainThread())方法
public final Observable observeOn(Scheduler scheduler) {
return this.observeOn(scheduler, false, bufferSize());
}
该方法调用了重载方法
public final Observable observeOn(Scheduler scheduler, boolean delayError, int bufferSize) {
ObjectHelper.requireNonNull(scheduler, "scheduler is null");
ObjectHelper.verifyPositive(bufferSize, "bufferSize");
return RxJavaPlugins.onAssembly(new ObservableObserveOn(this, scheduler, delayError, bufferSize));
}
这个和前面那个设置线程的基本都差不多，同样的ObservableObserveOn也是Observable的子类
public final class ObservableObserveOn extends AbstractObservableWithUpstream {
final Scheduler scheduler;
final boolean delayError;
final int bufferSize;
public ObservableObserveOn(ObservableSource source, Scheduler scheduler, boolean delayError, int bufferSize) {
super(source);
this.scheduler = scheduler;
this.delayError = delayError;
this.bufferSize = bufferSize;
}
同样的ObservableObserveOn也是Observable的子类
执行完observeOn方法后返回的是ObservableObserveOn对象,里面的source是前面的ObservableSubscribeOn对象，scheduler是AndroidSchedulers.mainThread()生成的对象
看最后的subscribe方法
onSubscribe方法
4 到最后执行了subscribe方法，也就是封装到最后一个对象执行此方法，RxJavaPlugins.onSubscribe(this, observer)返回的就是传入的observer对象;最后执行了subscribeActual方法
public final void subscribe(Observer observer) {
ObjectHelper.requireNonNull(observer, "observer is null");
try {
observer = RxJavaPlugins.onSubscribe(this, observer);
ObjectHelper.requireNonNull(observer, "Plugin returned null Observer");
this.subscribeActual(observer);
} catch (NullPointerException var4) {
throw var4;
} catch (Throwable var5) {
Exceptions.throwIfFatal(var5);
RxJavaPlugins.onError(var5);
NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
npe.initCause(var5);
throw npe;
}
}
执行subscribeActual方法时发现该方法是个抽象方法
protected abstract void subscribeActual(Observer var1);
总结前面的
- create方法把我们创建的ObservableOnSubscribe对象封装到ObservableCreate对象
- subscribeOn方法把ObservableCreate对象封装到ObservableSubscribeOn对象
- observeOn方法，把ObservableSubscribeOn对象封装到ObservableObserveOn对象
- onSubscribe方法，其实就是调用ObservableObserveOn对象的方法了，该方法传入了一个Observer，这个Observer就是最后的BaseObserver回调对象
封装的顺序如下
我们创建的ObservableOnSubscribe->ObservableCreate->ObservableSubscribeOn->ObservableObserveOn，并且ObservableCreate，ObservableSubscribeOn，ObservableObserveOn都是Observable的子类
了解这个封装顺序很重要，因为下面的调用前面是一步一步往前回调的。
根据对象的封装情况，我们再从调用的顺序再一步一步往下分析
查看我们的代码，我也是把这个回调给调用者。先记着这个receiver就是我们自己的回调对象
public void sortMp3InfosByTitleByRx(BaseObserver> receiver){
Observable.create(new ObservableOnSubscribe>() {
@Override
public void subscribe(ObservableEmitter> observableEmitter) throws Exception {
MusicInfoDao dao=daoSession.getMusicInfoDao();
DebugLog.d("subscribe:"+Thread.currentThread().getName());
List list=dao.queryBuilder().orderAsc(com.music.bean.MusicInfoDao.Properties.TitleKey).list();
if (list.isEmpty()){
DebugLog.d("本地数据没有，去手机多媒体数据库查询");
list.addAll(MusicModel.getInstance().sortMp3InfosByTitle(MusicApplication.getInstance()));
}else{
DebugLog.d("从本地数据库获取 ");
MusicModel.getInstance().getMusicList().addAll(list);
}
musicInfoList.addAll(list);
observableEmitter.onNext(list);
observableEmitter.onComplete();
}
}).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).subscribe(receiver);
}
由前面分析得知，此时执行subscribe方法的是一个ObservableObserveOn对象，因此我们继续查看
ObservableObserveOn对象里面的subscribe方法，发现里面没有这个方法，查看父类AbstractObservableWithUpstream，里面也没有这个方法，继续父类Observable,里面有这个方法
总结：Observable子类调用subscribe方法,如果没有复写该方法，最终都是自己subscribeActual方法
@SchedulerSupport("none")
public final void subscribe(Observer observer) {
ObjectHelper.requireNonNull(observer, "observer is null");
try {
observer = RxJavaPlugins.onSubscribe(this, observer);
ObjectHelper.requireNonNull(observer, "Plugin returned null Observer");
this.subscribeActual(observer);
} catch (NullPointerException var4) {
throw var4;
} catch (Throwable var5) {
Exceptions.throwIfFatal(var5);
RxJavaPlugins.onError(var5);
NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
npe.initCause(var5);
throw npe;
}
}
查看ObservableObserveOn的subscribeActual方法,这个observer是我们传入的revicer对象,由前面分析得知，ObservableObserveOn里面的source是ObservableSubscribeOn对象，这个source对象就是ObservableSubscribeOn对象，因此这里又回调了ObservableSubscribeOn对象的subscribe方法，并且还创建了一个Worker对象，把我们的revicer对象封装到一个ObservableObserveOn.ObserveOnObserver对象里。
ObservableObserveOn的subscribeActual方法
protected void subscribeActual(Observer observer) {
if(this.scheduler instanceof TrampolineScheduler) {
this.source.subscribe(observer);
} else {
Worker w = this.scheduler.createWorker();
this.source.subscribe(new ObservableObserveOn.ObserveOnObserver(observer, w, this.delayError, this.bufferSize));
}
}
这里的scheduler是rxandroid包下面的HandlerScheduler类
HandlerScheduler 笔记
而这里创建一个worker对象
private static final class HandlerWorker extends Worker {
public Disposable schedule(Runnable run, long delay, TimeUnit unit) {
if(run == null) {
throw new NullPointerException("run == null");
} else if(unit == null) {
throw new NullPointerException("unit == null");
} else if(this.disposed) {
return Disposables.disposed();
} else {
run = RxJavaPlugins.onSchedule(run);
HandlerScheduler.ScheduledRunnable scheduled = new HandlerScheduler.ScheduledRunnable(this.handler, run);
Message message = Message.obtain(this.handler, scheduled);
message.obj = this;
this.handler.sendMessageDelayed(message, unit.toMillis(delay));
if(this.disposed) {
this.handler.removeCallbacks(scheduled);
return Disposables.disposed();
} else {
return scheduled;
}
}
}
public void dispose() {
this.disposed = true;
this.handler.removeCallbacksAndMessages(this);
}
public boolean isDisposed() {
return this.disposed;
}
}
这个类主要看schedule方法，很显然是利用handler回调到主线程,这里暂且先不管这个类，后面调用的时候再回过来看。
继续看ObservableObserveOn的subscribeActual方法
protected void subscribeActual(Observer observer) {
if(this.scheduler instanceof TrampolineScheduler) {
this.source.subscribe(observer);
} else {
Worker w = this.scheduler.createWorker();
this.source.subscribe(new ObservableObserveOn.ObserveOnObserver(observer, w, this.delayError, this.bufferSize));
}
}
既然这个source是ObservableSubscribeOn对象，而这个ObservableSubscribeOn对象也是Observable的子类，由我们前面的分析得知，如果是Observable的子类，调用subsribe方法，就是调用subsribeActual方法，因此我们直接看ObservableSubscribeOn对象的subsribeActual方法，
ObservableSubscribeOn对象的subsribeActual方法
public void subscribeActual(Observer s) {
ObservableSubscribeOn.SubscribeOnObserver parent = new ObservableSubscribeOn.SubscribeOnObserver(s);
s.onSubscribe(parent);
parent.setDisposable(this.scheduler.scheduleDirect(new ObservableSubscribeOn.SubscribeTask(parent)));
}
这个SubscribeOnObserver类基本上就是对传入的s对象做了代理
查看s.onSubscribe方法，这个s就是前面ObservableObserveOn.ObserveOnObserver对象，该对象里面有我们的receiver对象和一个AndroidSchedulers.mainThread()生成的Worker对象
查看ObservableObserveOn.ObserveOnObserver对象的onSubscribe方法方法，由于传入进去的parent对象并不是QueueDisposable的子类，因此不会进入if语句里面，查看this.actual.onSubscribe(this);这个actual就是构造器时传入的对象，也就是我们的回调对象。
public void onSubscribe(Disposable s) {
if(DisposableHelper.validate(this.s, s)) {
this.s = s;
if(s instanceof QueueDisposable) {
QueueDisposable qd = (QueueDisposable)s;
int m = qd.requestFusion(7);
if(m == 1) {
this.sourceMode = m;
this.queue = qd;
this.done = true;
this.actual.onSubscribe(this);
this.schedule();
return;
}
if(m == 2) {
this.sourceMode = m;
this.queue = qd;
this.actual.onSubscribe(this);
return;
}
}
this.queue = new SpscLinkedArrayQueue(this.bufferSize);
this.actual.onSubscribe(this);
}
}
到这里就调用了我们BaseObserver的onSubscribe方法，再看后面是啥时候调用其他方法的
继续看subscribeActual的方法，执行完s.onSubscribe(parent);后执行
parent.setDisposable(this.scheduler.scheduleDirect(new ObservableSubscribeOn.SubscribeTask(parent)));
ObservableSubscribeOn对象的subsribeActual方法
public void subscribeActual(Observer s) {
ObservableSubscribeOn.SubscribeOnObserver parent = new ObservableSubscribeOn.SubscribeOnObserver(s);
s.onSubscribe(parent);
parent.setDisposable(this.scheduler.scheduleDirect(new ObservableSubscribeOn.SubscribeTask(parent)));
}
这里的s就是是ObservableObserveOn.ObserveOnObserver对象，该对象里面有我们的receiver对象和一个AndroidSchedulers.mainThread()生成的Worker对象
parent把前面的传入的参数s进行一个封装，里面调用方法基本也就是调用s的方法
这里又把parent封装到ObservableSubscribeOn.SubscribeTask对象里，
ObservableSubscribeOn.SubscribeTask实现了Runnable接口，那主要代码在run方法里面，
run方法执行了ObservableSubscribeOn里面source的subscribe方法。我们知道ObservableSubscribeOn里面封装的是ObservableCreate对象，因此这个方法里面调用的ObservableCreate对象的subscribe方法，这个我们先放着，看后面的代码是怎么切换线程的并且调用这个run方法的
SubscribeTask 笔记
final class SubscribeTask implements Runnable {
private final ObservableSubscribeOn.SubscribeOnObserver
SubscribeTask(ObservableSubscribeOn.SubscribeOnObserver this$0) {
this.parent = parent;
}
public void run() {
ObservableSubscribeOn.this.source.subscribe(this.parent);
}
}
继续查看scheduler对象的scheduleDirect方法
先看schedule怎么创建的
这个scheduler是创建ObservableSubscribeOn对象时创建的，找到前面创建ObservableSubscribeOn对象的代码
public final Observable observeOn(Scheduler scheduler) {
return this.observeOn(scheduler, false, bufferSize());
}
该方法调用了重载方法
public final Observable observeOn(Scheduler scheduler, boolean delayError, int bufferSize) {
ObjectHelper.requireNonNull(scheduler, "scheduler is null");
ObjectHelper.verifyPositive(bufferSize, "bufferSize");
return RxJavaPlugins.onAssembly(new ObservableObserveOn(this, scheduler, delayError, bufferSize));
}
创建new ObservableObserveOn(this, scheduler, delayError, bufferSize)，时这个scheuler就是我们调用Schedulers.io()传入进去的。
scheduler的scheduleDirect方法
@NonNull
public Disposable scheduleDirect(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) {
Scheduler.Worker w = this.createWorker();
Runnable decoratedRun = RxJavaPlugins.onSchedule(run);
Scheduler.DisposeTask task = new Scheduler.DisposeTask(decoratedRun, w);
w.schedule(task, delay, unit);
return task;
}
Scheduler主要是调用其createWorker生成的Worker对象的schedule的方法.而我们用的是Schedulers.io()生成的是NewThreadScheduler类
NewThreadScheduler类的创建的是一个NewThreadWorker。
@NonNull
public Worker createWorker() {
return new NewThreadWorker(this.threadFactory);
}
NewThreadWorker类的schedule方法，调用了重载方法，重载方法调用了scheduleActual方法
@NonNull
public Disposable schedule(@NonNull Runnable run) {
return this.schedule(run, 0L, (TimeUnit)null);
}
@NonNull
public Disposable schedule(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit) {
return (Disposable)(this.disposed?EmptyDisposable.INSTANCE:this.scheduleActual(action, delayTime, unit, (DisposableContainer)null));
}
@NonNull
public ScheduledRunnable scheduleActual(Runnable run, long delayTime, @NonNull TimeUnit unit, @Nullable DisposableContainer parent) {
Runnable decoratedRun = RxJavaPlugins.onSchedule(run);
ScheduledRunnable sr = new ScheduledRunnable(decoratedRun, parent);
if(parent != null && !parent.add(sr)) {
return sr;
} else {
try {
Object f;
if(delayTime <= 0L) {
f = this.executor.submit(sr);
} else {
f = this.executor.schedule(sr, delayTime, unit);
}
sr.setFuture((Future)f);
} catch (RejectedExecutionException var10) {
if(parent != null) {
parent.remove(sr);
}
RxJavaPlugins.onError(var10);
}
return sr;
}
}
再看前面 调用的代码
ObservableSubscribeOn对象的subsribeActual方法，
public void subscribeActual(Observer s) {
ObservableSubscribeOn.SubscribeOnObserver parent = new ObservableSubscribeOn.SubscribeOnObserver(s);
s.onSubscribe(parent);
parent.setDisposable(this.scheduler.scheduleDirect(new ObservableSubscribeOn.SubscribeTask(parent)));
}
ObservableSubscribeOn.SubscribeTask是一个实现了Runnable的子类，而调用这个scheduler的里面的Worker对象就是NewThreadWorker，这个对象里面有个线程池，运行在这里的代码都是在子线程中进行的，ObservableSubscribeOn.SubscribeTask根据时间是否直接提交到线程池中，还是延迟提交。
前面在SubscribeTask 笔记记录，现在这里的参数run就是前面的SubscribeTask对象，这里又封装成一个ScheduledRunnable对象，不过这个ScheduledRunnable对象调用的也是传入run的方法。
再查看SubscribeTask类，调用的是ObservableSubscribeOn里面source对象的方法， 也就是ObservableCreate的方法
final class SubscribeTask implements Runnable {
private final ObservableSubscribeOn.SubscribeOnObserver parent;
SubscribeTask(ObservableSubscribeOn.SubscribeOnObserver this$0) {
this.parent = parent;
}
public void run() {
ObservableSubscribeOn.this.source.subscribe(this.parent);
}
}
根据前面总结得知，调用subscribe方法就是调用ObservableCreate的subscribeActual方法
ObservableCreate的subscribeActual方法
protected void subscribeActual(Observer observer) {
ObservableCreate.CreateEmitter parent = new ObservableCreate.CreateEmitter(observer);
observer.onSubscribe(parent);
try {
this.source.subscribe(parent);
} catch (Throwable var4) {
Exceptions.throwIfFatal(var4);
parent.onError(var4);
}
}
这里继续调用的source，也就是我们自己创建的一个ObservableOnSubscribe
调用流程:
ObservableObserveOn.subscribeActual调用里面source也就是ObservableSubscribeOn.subscribeActual方法
ObservableSubscribeOn.subscribeActual方法根据生成的Worker,然后执行里面source也就是ObservableCreate的subscribeActual方法
ObservableCreate的subscribeActual方法调用里面的source也就是我们创建的对象的onSubscribe方法，了传入的我们的业务类里面的onSubscribe方法
Schedulers.io() 会生成一个NewThreadScheduler，NewThreadScheduler里面的Worker是一个NewThreadWorker类，该类里面有个线程池。把我们创建的业务逻辑类里面的subscribe方法运行在子线程中
但是我们在subscribe方法里面也调用onNext和complete方法，为什么我们的BaseObserver的onNext方法和compete方法却回调到主线程了呢？
此onNext和Complete方法非我们的BaseObserver的onNext方法和compete方法，那我们在subscribe里面调用的这个onNext和onCompete调用的是哪个对象的呢？
这个时候我们从调用的方法onSubscribe往回看
当我们调用到create().subscribeOn().observeOn().onSubscribe时调用这个对象是ObservableObserveOn
因此我们看ObservableObserveOn的subscribeActual方法
ObservableObserveOn的subscribeActual方法，该方法把我们的传入的observer参数进行了封装，并且还传入了一个Worker
这个时候参数就是个ObservableObserveOn.ObserveOnObserver对象
protected void subscribeActual(Observer observer) {
if(this.scheduler instanceof TrampolineScheduler) {
this.source.subscribe(observer);
} else {
Worker w = this.scheduler.createWorker();
this.source.subscribe(new ObservableObserveOn.ObserveOnObserver(observer, w, this.delayError, this.bufferSize));
}
}
继续看
ObservableSubscribeOn对象的subsribeActual方法
这时候把前面封装的参数又进行了封装
这个时候参数就是个ObservableSubscribeOn.SubscribeOnObserver对象
public void subscribeActual(Observer s) {
ObservableSubscribeOn.SubscribeOnObserver parent = new ObservableSubscribeOn.SubscribeOnObserver(s);
s.onSubscribe(parent);
parent.setDisposable(this.scheduler.scheduleDirect(new ObservableSubscribeOn.SubscribeTask(parent)));
}
ObservableCreate的subscribeActual方法
这个时候参数就是个ObservableCreate.CreateEmitter对象
protected void subscribeActual(Observer observer) {
ObservableCreate.CreateEmitter parent = new ObservableCreate.CreateEmitter(observer);
observer.onSubscribe(parent);
try {
this.source.subscribe(parent);
} catch (Throwable var4) {
Exceptions.throwIfFatal(var4);
parent.onError(var4);
}
}
虽然经过层层封装，但是基本这些封装都只是简单的调用封装对象里面的方法，也就是说ObservableCreate.CreateEmitter调用的是ObservableSubscribeOn.SubscribeOnObserver的方法，ObservableSubscribeOn.SubscribeOnObserver调用的又是ObservableObserveOn.ObserveOnObserver里面的代码，而重要的还是ObserveOnObserver里面的代码
public void sortMp3InfosByTitleByRx(BaseObserver> receiver)
Observable.create(new ObservableOnSubscribe>() {
@Override
public void subscribe(ObservableEmitter> observableEmitter) throws Exception {
MusicInfoDao dao=daoSession.getMusicInfoDao();
DebugLog.d("subscribe:"+Thread.currentThread().getName());
List list=dao.queryBuilder().orderAsc(com.music.bean.MusicInfoDao.Properties.TitleKey).list();
if (list.isEmpty()){
DebugLog.d("本地数据没有，去手机多媒体数据库查询");
list.addAll(MusicModel.getInstance().sortMp3InfosByTitle(MusicApplication.getInstance()));
}else{
DebugLog.d("从本地数据库获取 ");
MusicModel.getInstance().getMusicList().addAll(list);
}
musicInfoList.addAll(list);
observableEmitter.onNext(list);
observableEmitter.onComplete();
}
}).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).subscribe(receiver);
现在我们知道，当我们的业务里面的subscribe方法里面的参数的onNext和onComplete方法其实就是调用ObservableObserveOn.ObserveOnObserver里面的方法
既然这个类是主要的，那我们再看看这个创建的时候
ObservableObserveOn.ObserveOnObserver对象
protected void subscribeActual(Observer observer) {
if(this.scheduler instanceof TrampolineScheduler) {
this.source.subscribe(observer);
} else {
Worker w = this.scheduler.createWorker();
this.source.subscribe(new ObservableObserveOn.ObserveOnObserver(observer, w, this.delayError, this.bufferSize));
}
}
传入的这个observer就是我们的回调，赋值给了内部的actual对象，而这个Worker就是HandlerScheduler生成的HandlerWorker。具体可前面查看HanlderWork笔记
ObserveOnObserver(Observer actual, Worker worker, boolean delayError, int bufferSize) {
this.actual = actual;
this.worker = worker;
this.delayError = delayError;
this.bufferSize = bufferSize;
}
查看ObservableObserveOn.ObserveOnObserver的onNext方法
public void onNext(T t) {
if(!this.done) {
if(this.sourceMode != 2) {
this.queue.offer(t);
}
this.schedule();
}
}
这里把参数放入queue队列里面，并没有直接调用我们的onNext方法，调用了内部schedule方法
void schedule() {
if(this.getAndIncrement() == 0) {
this.worker.schedule(this);
}
}
这里也是调用了worker的schedule方法，并且把自己传入参数，因为ObservableObserveOn.ObserveOnObserver实现了Runnable接口,最终也会调用run方法
根据前面HandlerScheduler 笔记 ，这里的run方法就是利用Handler切换到主线程了。所以下面的调用方法也就会在主线程中执行
由于没有这个outputFused这个值，因此走drainNormal方法
public void run() {
if(this.outputFused) {
this.drainFused();
} else {
this.drainNormal();
}
}
里面调用了actual的next方法，而这个actual就是我们传入的BaseObserver，而此时，已经在主线程运行了。
这里方法首先调用checkTerminated方法，检查是否继续往下运行，由于done为false,这里继续走入另一个while循环
这个循环就一遍一遍的从queue里面获取参数数据，并且回调给BaseObserver的onNext方法，直到获取完毕，再调用checkTerminated方法时回调BaseObserver的onComplete方法，
void drainNormal() {
int missed = 1;
SimpleQueue q = this.queue;
Observer a = this.actual;
do {
if(this.checkTerminated(this.done, q.isEmpty(), a)) {
return;
}
while(true) {
boolean d = this.done;
Object v;
try {
v = q.poll();
} catch (Throwable var7) {
Exceptions.throwIfFatal(var7);
this.s.dispose();
q.clear();
a.onError(var7);
this.worker.dispose();
return;
}
boolean empty = v == null;
if(this.checkTerminated(d, empty, a)) {
return;
}
if(empty) {
missed = this.addAndGet(-missed);
break;
}
a.onNext(v);
}
} while(missed != 0);
}
每次调用这个方法都会往queue里面添加一个数据
public void onNext(T t) {
if(!this.done) {
if(this.sourceMode != 2) {
this.queue.offer(t);
}
this.schedule();
}
}
在checkTerminated方法里，如果queue里面为null时，并且调用过onComplete()或者onError方法的话，就会回调给外部调用的onComplete方法和onError方法
boolean checkTerminated(boolean d, boolean empty, Observer a) {
if(this.cancelled) {
this.queue.clear();
return true;
} else {
if(d) {
Throwable e = this.error;
if(this.delayError) {
if(empty) {
if(e != null) {
a.onError(e);
} else {
a.onComplete();
}
this.worker.dispose();
return true;
}
} else {
if(e != null) {
this.queue.clear();
a.onError(e);
this.worker.dispose();
return true;
}
if(empty) {
a.onComplete();
this.worker.dispose();
return true;
}
}
}
return false;
}
}
至此分析完毕
总结：当我们调用其方法时，里面对我们传入的参数进行封装，并且如果调用了切换线程的方法，会把对应的scheduler也添加进去，这样根据相应scheduler在相应的线程里面执行代码,封装的类都是Observable的子类，而Observable类编写了大量通用方法，因此可以方便简洁的进行链式调用