RxJava 允许我们将原本嵌套的异步任务处理,转换为链式的编程方式来处理。这样会让代码看上去更清爽,逻辑处理上也更加清晰。
而且 RxJava 在此基础上还扩展了很多函数,能提供更加丰富多样的调用方式。本片文章主要介绍一下简单链路下 RxJava 是如何运行的。
使用示例
Observable<Object> objectObservable = Observable.create(new ObservableOnSubscribe<Object>() {
@Override
public void subscribe(ObservableEmitter<Object> emitter) throws Exception {
}
});
objectObservable.map(new Function<Object, Object>() {
@Override
public Object apply(Object o) throws Exception {
return null;
}
});
objectObservable.subscribeOn(Schedulers.io());
objectObservable.observeOn(AndroidSchedulers.mainThread());
objectObservable.subscribe(new Observer<Object>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Object o) {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
源码解析
Observable.create
public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
ObjectHelper.requireNonNull(source, "source is null");
return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
}
// 返回 ObservableCreate 并将 ObservableOnSubscribe 保存在 source 字段中
public final class ObservableCreate<T> extends Observable<T> {
public ObservableCreate(ObservableOnSubscribe<T> source) {
this.source = source;
}
}
ObservableCreate.map
public final <R> Observable<R> map(Function<? super T, ? extends R> mapper) {
ObjectHelper.requireNonNull(mapper, "mapper is null");
return RxJavaPlugins.onAssembly(new ObservableMap<T, R>(this, mapper));
}
// 返回 ObservableMap 并将 ObservableCreate 保存在 source 字段中, 将 Function 保存在
// function 字段中
public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {
public ObservableMap(ObservableSource<T> source, Function<? super T, ? extends U> function) {
super(source);
this.function = function;
}
}
ObservableMap.subscribeOn
public final Observable<T> subscribeOn(Scheduler scheduler) {
ObjectHelper.requireNonNull(scheduler, "scheduler is null");
return RxJavaPlugins.onAssembly(new ObservableSubscribeOn<T>(this, scheduler));
}
// 返回 ObservableSubscribeOn 并将 ObservableMap 保存在 source 字段中,将 Scheduler.io()
// 保存在 scheduler 中
public final class ObservableSubscribeOn<T> extends AbstractObservableWithUpstream<T, T> {
public ObservableSubscribeOn(ObservableSource<T> source, Scheduler scheduler) {
super(source);
this.scheduler = scheduler;
}
}
ObservableSubscribeOn.observeOn
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<T>(this, scheduler, delayError, bufferSize));
}
// 返回 ObservableObserveOn 并将 ObservableSubscribeOn 保存在 source 字段中
// 将 AndroidSchedulers.mainThread() 保存在 scheduler 字段中
public final class ObservableObserveOn<T> extends AbstractObservableWithUpstream<T, T> {
public ObservableObserveOn(ObservableSource<T> source, Scheduler scheduler, boolean delayError, int bufferSize) {
super(source);
this.scheduler = scheduler;
this.delayError = delayError;
this.bufferSize = bufferSize;
}
}
ObservableObserveOn.subscribe
public final void subscribe(Observer<? super T> observer) {
ObjectHelper.requireNonNull(observer, "observer is null");
try {
observer = RxJavaPlugins.onSubscribe(this, observer);
ObjectHelper.requireNonNull(observer, "The RxJavaPlugins.onSubscribe hook returned a null Observer. Please change the handler provided to RxJavaPlugins.setOnObservableSubscribe for invalid null returns. Further reading: https://github.com/ReactiveX/RxJava/wiki/Plugins");
subscribeActual(observer);
} catch (NullPointerException e) { // NOPMD
throw e;
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
// can't call onError because no way to know if a Disposable has been set or not
// can't call onSubscribe because the call might have set a Subscription already
RxJavaPlugins.onError(e);
NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
npe.initCause(e);
throw npe;
}
}
实际上调用到了 ObservableObserveOn 的 subscribeActual 方法
@Override
protected void subscribeActual(Observer<? super T> observer) {
if (scheduler instanceof TrampolineScheduler) {
source.subscribe(observer);
} else {
Scheduler.Worker w = scheduler.createWorker();
// 将 observer 包装成了 ObservenObserver 传递给了上一层
source.subscribe(new ObserveOnObserver<T>(observer, w, delayError, bufferSize));
}
}
source 是指 ObservableSubscribeOn
@Override
public void subscribeActual(final Observer<? super T> observer) {
// 封装为了 SubscribeOnObserver
final SubscribeOnObserver<T> parent = new SubscribeOnObserver<T>(observer);
// 执行了 observer 的 subscribe 方法
observer.onSubscribe(parent);
// 主要是通过 scheduler.scheduleDirect 将线程切换到 scheduler 中, 这里是 Schedulers
//.io()
parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
}
Scheculer.io()
static {
IO = RxJavaPlugins.initIoScheduler(new IOTask());
}
static final class IOTask implements Callable<Scheduler> {
@Override
public Scheduler call() throws Exception {
return IoHolder.DEFAULT;
}
}
static final class IoHolder {
static final Scheduler DEFAULT = new IoScheduler();
}
所以 scheduler.scheduleDirect 实际是执行 IoScheduler 的 scheduleDirect 方法
public Disposable scheduleDirect(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) {
// 创建了 EventLoopWorker
final Worker w = createWorker();
final Runnable decoratedRun = RxJavaPlugins.onSchedule(run);
DisposeTask task = new DisposeTask(decoratedRun, w);
// 执行了 work 的 schedule 方法
w.schedule(task, delay, unit);
return task;
}
public Worker createWorker() {
return new EventLoopWorker(pool.get());
}
static final class EventLoopWorker extends Scheduler.Worker {
public Disposable schedule(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit) {
if (tasks.isDisposed()) {
// don't schedule, we are unsubscribed
return EmptyDisposable.INSTANCE;
}
// 执行 threadWorker 的 scheduleActual 方法
return threadWorker.scheduleActual(action, delayTime, unit, tasks);
}
}
// 可以看到最后执行的是 NewThreadWorker 的 scheduleActual 方法
static final class ThreadWorker extends NewThreadWorker {
private long expirationTime;
ThreadWorker(ThreadFactory threadFactory) {
super(threadFactory);
this.expirationTime = 0L;
}
public long getExpirationTime() {
return expirationTime;
}
public void setExpirationTime(long expirationTime) {
this.expirationTime = expirationTime;
}
}
public class NewThreadWorker extends Scheduler.Worker implements Disposable {
// excutor 为线程池
private final ScheduledExecutorService executor;
@NonNull
public ScheduledRunnable scheduleActual(final Runnable run, long delayTime, @NonNull TimeUnit unit, @Nullable DisposableContainer parent) {
Runnable decoratedRun = RxJavaPlugins.onSchedule(run);
ScheduledRunnable sr = new ScheduledRunnable(decoratedRun, parent);
if (parent != null) {
if (!parent.add(sr)) {
return sr;
}
}
Future<?> f;
try {
// 通过 executor 直接执行或者延时执行
if (delayTime <= 0) {
f = executor.submit((Callable<Object>)sr);
} else {
f = executor.schedule((Callable<Object>)sr, delayTime, unit);
}
sr.setFuture(f);
} catch (RejectedExecutionException ex) {
if (parent != null) {
parent.remove(sr);
}
RxJavaPlugins.onError(ex);
}
return sr;
}
}
所以 ObservableSubscribeOn.subscribeActual 执行完后, 后续的操作都在 IoScheduler 指定的线程池中进行。
继续往下看, 线程池最终会执行到 SubscribeTask 的 run 方法, 实际上又执行到了 source.subscribe 方法
final class SubscribeTask implements Runnable {
private final SubscribeOnObserver<T> parent;
SubscribeTask(SubscribeOnObserver<T> parent) {
this.parent = parent;
}
@Override
public void run() {
source.subscribe(parent);
}
}
source 指的是 ObservableMap , 继续往下看
public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {
// 传入的是 SubscribeOnObserver
public void subscribeActual(Observer<? super U> t) {
// 包装成 MapObserver 继续往上传入
source.subscribe(new MapObserver<T, U>(t, function));
}
}
这里的source 指的是 ObserveableCreate
public final class ObservableCreate<T> extends Observable<T> {
protected void subscribeActual(Observer<? super T> observer) {
CreateEmitter<T> parent = new CreateEmitter<T>(observer);
// 执行 observer 的 obSubscribe 方法
observer.onSubscribe(parent);
try {
// 继续执行 subscribe 方法 传入 CreateEmitter
source.subscribe(parent);
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
parent.onError(ex);
}
}
}
这里的 source 指的是 ObservableOnSubscribe , 即传入 Observable.create 方法的参数
Observable.create(new ObservableOnSubscribe<Object>() {
@Override
public void subscribe(ObservableEmitter<Object> emitter) throws Exception {
// 在这里一般需执行 emitter.onNext()
}
})
解下来是第三个流程, 基本就是走 onNext 方法, 搜先看看 emitter 的 onNext 方法
static final class CreateEmitter<T>
extends AtomicReference<Disposable>
implements ObservableEmitter<T>, Disposable {
@Override
public void onNext(T t) {
if (t == null) {
onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
return;
}
if (!isDisposed()) {
// 这个 Observer 指的是 MapObserver
observer.onNext(t);
}
}
}
MapObserver 的 onNext 方法
static final class MapObserver<T, U> extends BasicFuseableObserver<T, U> {
// 这个是 BasicFuseableObservable 的属性, 可以看到实际就是构造方法传入的 observer
protected final Observer<? super R> downstream;
public BasicFuseableObserver(Observer<? super R> downstream) {
this.downstream = downstream;
}
@Override
public void onNext(T t) {
if (done) {
return;
}
if (sourceMode != NONE) {
downstream.onNext(null);
return;
}
U v;
try {
// 会先执行 apply 方法
v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
} catch (Throwable ex) {
fail(ex);
return;
}
// 让后再执行 downStrean 的 onNext
downstream.onNext(v);
}
}
这个 downstream 根据之前的分析,实际上就是 SubscribeOnObserver.
static final class SubscribeOnObserver<T> extends AtomicReference<Disposable> implements Observer<T>, Disposable {
@Override
public void onNext(T t) {
downstream.onNext(t);
}
}
由于 SubscribeOn 的切换是发生在 subscribeActual 中, 所以 onNext 中不会做任何处理,直接执行 onNext.
这个 downstream 指的是 ObserveOnObserver
static final class ObserveOnObserver<T> extends BasicIntQueueDisposable<T>
implements Observer<T>, Runnable {
static final class ObserveOnObserver<T> extends BasicIntQueueDisposable<T>
@Override
public void onNext(T t) {
if (done) {
return;
}
if (sourceMode != QueueDisposable.ASYNC) {
queue.offer(t);
}
schedule();
}
// 通过 worker 来执行 schedule 操作
void schedule() {
if (getAndIncrement() == 0) {
worker.schedule(this);
}
}
// worker 通过 scheduler 来创建的,然后传入的
ObserveOnObserver(Observer<? super T> actual, Scheduler.Worker worker, boolean delayError, int bufferSize) {
this.downstream = actual;
this.worker = worker;
this.delayError = delayError;
this.bufferSize = bufferSize;
}
}
这个 scheduler 通过传参数来确认,为 AndroidSchedulers.mainThread()
public static Scheduler mainThread() {
return RxAndroidPlugins.onMainThreadScheduler(MAIN_THREAD);
}
private static final Scheduler MAIN_THREAD = RxAndroidPlugins.initMainThreadScheduler(
new Callable<Scheduler>() {
@Override public Scheduler call() throws Exception {
return MainHolder.DEFAULT;
}
});
// 可以看到实际上是一个 HandlerScheduler 然后传入了一个主线程Looper 的 Handler
private static final class MainHolder {
static final Scheduler DEFAULT
= new HandlerScheduler(new Handler(Looper.getMainLooper()), false);
}
再看看 HandlerWorker
public Worker createWorker() {
return new HandlerWorker(handler, async);
}
private static final class HandlerWorker extends Worker {
private final Handler handler;
private final boolean async;
private volatile boolean disposed;
HandlerWorker(Handler handler, boolean async) {
this.handler = handler;
this.async = async;
}
@Override
@SuppressLint("NewApi") // Async will only be true when the API is available to call.
public Disposable schedule(Runnable run, long delay, TimeUnit unit) {
if (run == null) throw new NullPointerException("run == null");
if (unit == null) throw new NullPointerException("unit == null");
if (disposed) {
return Disposables.disposed();
}
run = RxJavaPlugins.onSchedule(run);
// 最终就是执行了 run 参数的 run 方法, run 参数实际就是 ObserveOnObserver
ScheduledRunnable scheduled = new ScheduledRunnable(handler, run);
Message message = Message.obtain(handler, scheduled);
message.obj = this; // Used as token for batch disposal of this worker's runnables.
if (async) {
message.setAsynchronous(true);
}
// 通过 handler 来处理,实际上就切换到主线程了
handler.sendMessageDelayed(message, unit.toMillis(delay));
// Re-check disposed state for removing in case we were racing a call to dispose().
if (disposed) {
handler.removeCallbacks(scheduled);
return Disposables.disposed();
}
return scheduled;
}
@Override
public void dispose() {
disposed = true;
handler.removeCallbacksAndMessages(this /* token */);
}
@Override
public boolean isDisposed() {
return disposed;
}
}
static final class ObserveOnObserver<T> extends BasicIntQueueDisposable<T>
implements Observer<T>, Runnable {
@Override
public void run() {
// 这个参数在过程中并没有改变,所以应该执行 else 此时已经切换了线程
if (outputFused) {
drainFused();
} else {
drainNormal();
}
}
void drainNormal() {
int missed = 1;
final SimpleQueue<T> q = queue;
// 实际上就是 subscribe 方法传递的 observer 了
final Observer<? super T> a = downstream;
for (;;) {
if (checkTerminated(done, q.isEmpty(), a)) {
return;
}
for (;;) {
boolean d = done;
T v;
try {
v = q.poll();
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
disposed = true;
upstream.dispose();
q.clear();
a.onError(ex);
worker.dispose();
return;
}
boolean empty = v == null;
if (checkTerminated(d, empty, a)) {
return;
}
if (empty) {
break;
}
// 最后执行了 onNext
a.onNext(v);
}
missed = addAndGet(-missed);
if (missed == 0) {
break;
}
}
}
}
这样一套简单的 RxJava 的流程就执行完了。
个人总结
总结来看,总共分为三个流程。
从 Observeble.create 到 subscribe() , 一层层将参数封装为 ObservableXXXX 对象。
从 ObservebleObserveOn.subscribeActual 到 ObservableOnSubscribe. subscribe 方法, 将参数封装为 xxxObserver 一层层向上传递
最后,从 CreateEmitter 的 onNext 到 Observer 的 onNext , 一层层解析执行 onNext 方法, 中间执行 apply 方法将参数进行处理后返回。
其中 subscribeOn 的线程切换在 subscribeActual 中, observeOn 的线程切换在 onNext 中。
实际上, RxJava 的设计是一种变式的观察者模式, 下一层只需观察上一层的执行结果即可, 而不是像传统的观察者模式一样,所有的观察者都去观察同一个观察着, 可以说,每一个对象既是观察者,也是被观察着。