RxJava 源码解读
一直以来在网上看到关于RxJava的使用博客都称赞RxJava使用起来非常简洁，即使业务逻辑非常复杂，它依然能够保持简洁。于是在个人项目也添加了RxJava和RxAndroid.秉着知其然知其所以然的态度，跟着调用方法一探其源码，
首选是调用方法。这个方法是获取手机里面的所有音乐文件信息，并且返回给回调者，并且这里的subscribe是运行在子线程中，回调则在主线程再更新UI
public void sortMp3InfosByTitleByRx(BaseObserver<List<MusicInfo>> receiver)
Observable.create(new ObservableOnSubscribe<List<MusicInfo>>() {
@Override
public void subscribe(ObservableEmitter<List<MusicInfo>> observableEmitter) throws Exception {
MusicInfoDao dao=daoSession.getMusicInfoDao();
DebugLog.d("subscribe:"+Thread.currentThread().getName());
List<MusicInfo> 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<T> implements Observer<T> {
@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 <T> Observable<T> create(ObservableOnSubscribe<T> 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<T> extends Observable<T> {
final ObservableOnSubscribe<T> source;
public ObservableCreate(ObservableOnSubscribe<T> source) {
this.source = source;
}
可以看到里面有个source属性就是创建对象传入的参数，后面的依然类似，创建对象是传入的参数大都赋值到对象里面的souce
RxJavaPlugins onAssembly方法
public static <T> Observable<T> onAssembly(@NonNull Observable<T> source) {
Function<? super Observable, ? extends Observable> f = onObservableAssembly;
return f != null?(Observable)apply(f, source):source;
}
onObservableAssembly是调用setOnObservableAssembly方法设置的
public static void setOnObservableAssembly(@Nullable Function<? super Observable, ? extends Observable> onObservableAssembly) {
if(lockdown) {
throw new IllegalStateException("Plugins can't be changed anymore");
} else {
onObservableAssembly = onObservableAssembly;
}
}
我们没有调用这个方法因此这个对象为Null
public static <T> Observable<T> create(ObservableOnSubscribe<T> 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<T> 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<T> source, Scheduler scheduler) {
super(source);
this.scheduler = scheduler;
}
也就是说ObservableSubscribeOn也是Observable的子类
执行完subscribeOn方法后返回的是ObservableSubscribeOn对象,里面的source是前面的ObservableCreate对象，scheduler是Schedulers.io()的,
observeOn方法
由于我们想要最终回调到主线程中，因此调用了observeOn(AndroidSchedulers.mainThread())方法
public final Observable<T> observeOn(Scheduler scheduler) {
return this.observeOn(scheduler, false, bufferSize());
}
该方法调用了重载方法
public final Observable<T> 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<T> extends AbstractObservableWithUpstream<T, T> {
final Scheduler scheduler;
final boolean delayError;
final int bufferSize;
public ObservableObserveOn(ObservableSource<T> 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<? super T> 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<? super T> var1);
总结前面的
1. create方法把我们创建的ObservableOnSubscribe对象封装到ObservableCreate对象
2. subscribeOn方法把ObservableCreate对象封装到ObservableSubscribeOn对象
3. observeOn方法，把ObservableSubscribeOn对象封装到ObservableObserveOn对象
4. onSubscribe方法，其实就是调用ObservableObserveOn对象的方法了，该方法传入了一个Observer，这个Observer就是最后的BaseObserver回调对象
封装的顺序如下
我们创建的ObservableOnSubscribe->ObservableCreate->ObservableSubscribeOn->ObservableObserveOn，并且ObservableCreate，ObservableSubscribeOn，ObservableObserveOn都是Observable的子类
了解这个封装顺序很重要，因为下面的调用前面是一步一步往前回调的。
根据对象的封装情况，我们再从调用的顺序再一步一步往下分析
查看我们的代码，我也是把这个回调给调用者。先记着这个receiver就是我们自己的回调对象
public void sortMp3InfosByTitleByRx(BaseObserver<List<MusicInfo>> receiver){
Observable.create(new ObservableOnSubscribe<List<MusicInfo>>() {
@Override
public void subscribe(ObservableEmitter<List<MusicInfo>> observableEmitter) throws Exception {
MusicInfoDao dao=daoSession.getMusicInfoDao();
DebugLog.d("subscribe:"+Thread.currentThread().getName());
List<MusicInfo> 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<? super T> 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<? super T> 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<? super T> 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<? super T> s) {
ObservableSubscribeOn.SubscribeOnObserver<T> 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<T> 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<? super T> s) {
ObservableSubscribeOn.SubscribeOnObserver<T> 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 parent;
SubscribeTask(ObservableSubscribeOn.SubscribeOnObserver<T> this$0) {
this.parent = parent;
}
public void run() {
ObservableSubscribeOn.this.source.subscribe(this.parent);
}
}
继续查看scheduler对象的scheduleDirect方法
先看schedule怎么创建的
这个scheduler是创建ObservableSubscribeOn对象时创建的，找到前面创建ObservableSubscribeOn对象的代码
public final Observable<T> observeOn(Scheduler scheduler) {
return this.observeOn(scheduler, false, bufferSize());
}
该方法调用了重载方法
public final Observable<T> 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<? super T> s) {
ObservableSubscribeOn.SubscribeOnObserver<T> 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<T> parent;
SubscribeTask(ObservableSubscribeOn.SubscribeOnObserver<T> this$0) {
this.parent = parent;
}
public void run() {
ObservableSubscribeOn.this.source.subscribe(this.parent);
}
}
根据前面总结得知，调用subscribe方法就是调用ObservableCreate的subscribeActual方法
ObservableCreate的subscribeActual方法
protected void subscribeActual(Observer<? super T> observer) {
ObservableCreate.CreateEmitter<T> parent = new ObservableCreate.CreateEmitter(observer);
observer.onSubscribe(parent);
try {
this.source.subscribe(parent);
} catch (Throwable var4) {
Exceptions.throwIfFatal(var4);
parent.onError(var4);
}
}
这里继续调用的source，也就是我们自己创建的一个ObservableOnSubscribe
扫一扫
1033
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
