RxJava源码分析
预备知识
给 Android 开发者的 RxJava 详解
深入浅出RxJava（一：基础篇）
主流程
分析的版本：
compile 'io.reactivex:rxandroid:1.2.1' compile 'io.reactivex:rxjava:1.1.6'
从调用开始分析，先来一段的代码
Observable.create(new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> subscriber) {
subscriber.onNext("");
Log.e("Observable Thread id ", ""+ Thread.currentThread().getId());
}
}).subscribeOn(Schedulers.io()).doOnSubscribe(new Action0() {
@Override
public void call() {
Log.e("doOnSubscribe Thread id", ""+ Thread.currentThread().getId());
}
}).observeOn(AndroidSchedulers.mainThread()).subscribe(new Subscriber<String>() {
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(String s) {
Log.e("Subscriber Thread id", ""+ Thread.currentThread().getId());
}
});先分析Observable.create（）源码如下：
public static <T> Observable<T> create(OnSubscribe<T> f) {
return new Observable<T>(hook.onCreate(f));
}
protected Observable(OnSubscribe<T> f) {
this.onSubscribe = f;
}Observable.create（）实际就是创建了一个Observable对象，并且这个对象的onSubscribe对象被赋值为我们new的onSubscribe。（hook.onCreate()什么都没干直接返回传入的参数）
假设创建的Observable对象为A，那么如下图
接下来A又调用了subscribeOn(Schedulers.io())，先来分析subscribeOn的源码
public final Observable<T> subscribeOn(Scheduler scheduler) {
if (this instanceof ScalarSynchronousObservable) {
return ((ScalarSynchronousObservable<T>)this).scalarScheduleOn(scheduler);
}
return create(new OperatorSubscribeOn<T>(this, scheduler));
}subscribeOn里面又调用了Observable.create创建返回了一个新的Observable对象，注意此时this是A，假设新创建的对象为B，那么如下图：
接着B又调用了doOnSubscribe
public final Observable<T> doOnSubscribe(final Action0 subscribe) {
return lift(new OperatorDoOnSubscribe<T>(subscribe));
} public final <R> Observable<R> lift(final Operator<? extends R, ? super T> operator) {
return new Observable<R>(new OnSubscribeLift<T, R>(onSubscribe, operator));
}doOnSubscribe里面调用了lift创建了一个新的Observable对象，注意new OnSubscribeLift中传入的onSubscribe为B对象的onSubscribe，假设新创建的对象为C，如下图
接着C对象又调用了observeOn(AndroidSchedulers.mainThread())
public final Observable<T> observeOn(Scheduler scheduler) {
return observeOn(scheduler, RxRingBuffer.SIZE);
}
public final Observable<T> observeOn(Scheduler scheduler, int bufferSize) {
return observeOn(scheduler, false, bufferSize);
} public final Observable<T> observeOn(Scheduler scheduler, boolean delayError, int bufferSize) {
if (this instanceof ScalarSynchronousObservable) {
return ((ScalarSynchronousObservable<T>)this).scalarScheduleOn(scheduler);
}
return lift(new OperatorObserveOn<T>(scheduler, delayError, bufferSize));
}observeOn中又调用了lift函数创建了一个新的Observable对象，注意new OnSubscribeLift中传入的onSubscribe为C对象的onSubscribe，假设新创建的对象为D，如下图
最后D调用subscribe，传入的参数为
new Subscriber<String>() {
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(String s) {
Log.e("Subscriber Thread id", ""+ Thread.currentThread().getId());
}
}假设传入的Subscriber对象为subscriber_org
接下来看 subscribe的源码
public final Subscription subscribe(Subscriber<? super T> subscriber) {
return Observable.subscribe(subscriber, this);
} static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T> observable) {
// validate and proceed
if (subscriber == null) {
throw new IllegalArgumentException("subscriber can not be null");
}
if (observable.onSubscribe == null) {
throw new IllegalStateException("onSubscribe function can not be null.");
/*
* the subscribe function can also be overridden but generally that's not the appropriate approach
* so I won't mention that in the exception
*/
}
// new Subscriber so onStart it
subscriber.onStart();
/*
* See https://github.com/ReactiveX/RxJava/issues/216 for discussion on "Guideline 6.4: Protect calls
* to user code from within an Observer"
*/
// if not already wrapped
if (!(subscriber instanceof SafeSubscriber)) {
// assign to `observer` so we return the protected version
subscriber = new SafeSubscriber<T>(subscriber);
}
// The code below is exactly the same an unsafeSubscribe but not used because it would
// add a significant depth to already huge call stacks.
try {
// allow the hook to intercept and/or decorate
hook.onSubscribeStart(observable, observable.onSubscribe).call(subscriber);
return hook.onSubscribeReturn(subscriber);
} catch (Throwable e) {
// special handling for certain Throwable/Error/Exception types
Exceptions.throwIfFatal(e);
// in case the subscriber can't listen to exceptions anymore
if (subscriber.isUnsubscribed()) {
RxJavaPluginUtils.handleException(hook.onSubscribeError(e));
} else {
// if an unhandled error occurs executing the onSubscribe we will propagate it
try {
subscriber.onError(hook.onSubscribeError(e));
} catch (Throwable e2) {
Exceptions.throwIfFatal(e2);
// if this happens it means the onError itself failed (perhaps an invalid function implementation)
// so we are unable to propagate the error correctly and will just throw
RuntimeException r = new OnErrorFailedException("Error occurred attempting to subscribe [" + e.getMessage() + "] and then again while trying to pass to onError.", e2);
// TODO could the hook be the cause of the error in the on error handling.
hook.onSubscribeError(r);
// TODO why aren't we throwing the hook's return value.
throw r;
}
}
return Subscriptions.unsubscribed();
}
}
先看前面两个if判断，subscriber为我们new出来的对象不为null，observable为对象D，D.onSubscribe不为null，所以再往下看
subscriber.onStart();调用subscribe就会马上回调到subscriber的onStart()，onStart执行是在调用subscribe的线程，如果在子线程调用subscribe，那么onStart也会在子线程调用。 so当我们请求网络之前显示时候 ，显示加载的动画放在onStart里面是可以的，但是调用subscribe的线程必须是主线程。如果想在子线程调用subscribe，但是又想在请求发生之前在主线程做什么事的话，onStart是满足不了的，可以使用doOnSubscribe（里面显示加载动画）结合subscribeOn。
接下来
if (!(subscriber instanceof SafeSubscriber)) {
// assign to `observer` so we return the protected version
subscriber = new SafeSubscriber<T>(subscriber);
}subscriber被封装成SafeSubscriber的对象，SafeSubscriber相当于Subscriber的安全版本，多了一些安全判断。在这里认为没有被封装就好。
再往下
hook.onSubscribeStart(observable, observable.onSubscribe).call(subscriber);
hook.onSubscribeStart什么都没干直接返回了observable.onSubscribe，这里的observable.onSubscribe为D对象的onSubscribe，而D的onSubscribe为new OnSubscribeLift（C.onSubscribe, new OperatorObserveOn(scheduler, delayError, bufferSize)），接着调用了D.onSubscribe的call方法，即OnSubscribeLift.call
那么先分析OnSubscribeLift.call
public OnSubscribeLift(OnSubscribe<T> parent, Operator<? extends R, ? super T> operator) {
this.parent = parent;
this.operator = operator;
}
@Override
public void call(Subscriber<? super R> o) {
try {
Subscriber<? super T> st = hook.onLift(operator).call(o);
try {
// new Subscriber created and being subscribed with so 'onStart' it
st.onStart();
parent.call(st);
} catch (Throwable e) {
// localized capture of errors rather than it skipping all operators
// and ending up in the try/catch of the subscribe method which then
// prevents onErrorResumeNext and other similar approaches to error handling
Exceptions.throwIfFatal(e);
st.onError(e);
}
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
// if the lift function failed all we can do is pass the error to the final Subscriber
// as we don't have the operator available to us
o.onError(e);
}
}先调用了hook.onLift(operator).call(o)，hook.onLift什么都干直接返回了operator，而此时的operator为OperatorObserveOn，那么再看OperatorObserveOn的call
public Subscriber<? super T> call(Subscriber<? super T> child) {
if (scheduler instanceof ImmediateScheduler) {
// avoid overhead, execute directly
return child;
} else if (scheduler instanceof TrampolineScheduler) {
// avoid overhead, execute directly
return child;
} else {
ObserveOnSubscriber<T> parent = new ObserveOnSubscriber<T>(scheduler, child, delayError, bufferSize);
parent.init();
return parent;
}
}call里面创建返回了一个ObserveOnSubscriber对象，并且把subscriber_org赋值给了ObserveOnSubscriber对象的child成员，ObserveOnSubscriber继承Subscriber。假设这个ObserveOnSubscriber为subscriber_D，那么如图
然后回到OnSubscribeLift.call中
st.onStart();
st为subscriber_D对象，即调用subscriber_D.onStart
接着往下看
parent.call(st);此时的parent为C.onSubscribe，而C.onSubscribe为onSubscribe = new OnSubscribeLift(B.onSubscribe , new OperatorDoOnSubscribe(Action0))。那么再看OnSubscribeLift.call
@Override
public void call(Subscriber<? super R> o) {
try {
Subscriber<? super T> st = hook.onLift(operator).call(o);
try {
// new Subscriber created and being subscribed with so 'onStart' it
st.onStart();
parent.call(st);
} catch (Throwable e) {
// localized capture of errors rather than it skipping all operators
// and ending up in the try/catch of the subscribe method which then
// prevents onErrorResumeNext and other similar approaches to error handling
Exceptions.throwIfFatal(e);
st.onError(e);
}
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
// if the lift function failed all we can do is pass the error to the final Subscriber
// as we don't have the operator available to us
o.onError(e);
}
}先看
Subscriber<? super T> st = hook.onLift(operator).call(o);operator为OperatorDoOnSubscribe类型，那么再看OperatorDoOnSubscribe.call
public Subscriber<? super T> call(final Subscriber<? super T> child) {
subscribe.call();
// Pass through since this operator is for notification only, there is
// no change to the stream whatsoever.
return Subscribers.wrap(child);
}先是调用subscribe.call()，而这里的subscribe为我们传入的new Aciton0对象
new Action0() {
@Override
public void call() {
Log.e("doOnSubscribe Thread id", ""+ Thread.currentThread().getId());
}
}接着Subscribers.wrap(child)又创建了一个Subscriber对象（回调的时候直接透传过去，没有的任何处理）
public static <T> Subscriber<T> wrap(final Subscriber<? super T> subscriber) {
return new Subscriber<T>(subscriber) {
@Override
public void onCompleted() {
subscriber.onCompleted();
}
@Override
public void onError(Throwable e) {
subscriber.onError(e);
}
@Override
public void onNext(T t) {
subscriber.onNext(t);
}
};
}假设这个Subscriber对象为subscriber_C,那么如图
再回到OnSubscribeLift.call中
st.onStart();
parent.call(st);此时parent为B.onSubscribe,而B.onSubscribe = new OperatorSubscribeOn(A, scheduler),那么再看OperatorSubscribeOn.call
public void call(final Subscriber<? super T> subscriber) {
final Worker inner = scheduler.createWorker();
subscriber.add(inner);
inner.schedule(new Action0() {
@Override
public void call() {
final Thread t = Thread.currentThread();
Subscriber<T> s = new Subscriber<T>(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（Schedulers.io()）创建了一个Worker对象inner，然后inner.schedule（Aciton0）把这个Aciton0加入线程池任务队列（此时Action0里面的call将在子线程执行），然后就返回到OnSubscribeLift.call,没异常就一直到返回到subscribe，然后执行
return hook.onSubscribeReturn(subscriber); 而里面什么都没干直接返回了subscriber，即subscriber_D
接下来分析Action0的call函数
new Action0() {
@Override
public void call() {
final Thread t = Thread.currentThread();
Subscriber<T> s = new Subscriber<T>(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);
}又创建了一个Subscriber对象，假设为subscriber_B,那么如图
接着调用
source.unsafeSubscribe(s);此时souce为A对象，s为subscriber_B,A为Observable类型
public final Subscription unsafeSubscribe(Subscriber<? super T> subscriber) {
try {
// new Subscriber so onStart it
subscriber.onStart();
// allow the hook to intercept and/or decorate
hook.onSubscribeStart(this, onSubscribe).call(subscriber);
return hook.onSubscribeReturn(subscriber);
} catch (Throwable e) {
// special handling for certain Throwable/Error/Exception types
Exceptions.throwIfFatal(e);
// if an unhandled error occurs executing the onSubscribe we will propagate it
try {
subscriber.onError(hook.onSubscribeError(e));
} catch (Throwable e2) {
Exceptions.throwIfFatal(e2);
// if this happens it means the onError itself failed (perhaps an invalid function implementation)
// so we are unable to propagate the error correctly and will just throw
RuntimeException r = new RuntimeException("Error occurred attempting to subscribe [" + e.getMessage() + "] and then again while trying to pass to onError.", e2);
// TODO could the hook be the cause of the error in the on error handling.
hook.onSubscribeError(r);
// TODO why aren't we throwing the hook's return value.
throw r;
}
return Subscriptions.unsubscribed();
}
}先看
subscriber.onStart();
这里的subscriber为subscriber_B
接着往下
hook.onSubscribeStart(this, onSubscribe).call(subscriber);相当于调用A.onSubscribe.call(subscriber_B)，而A.onSubscribe为
new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> subscriber) {
subscriber.onNext("");
Log.e("Observable Thread id ", ""+ Thread.currentThread().getId());
}
}先看
subscriber.onNext("");相当于调用subscriber_B.onNext,而subscriber_B.onNext则会调用subscriber_C.onNext，而subscriber_C.onNext则会调用subscriber_D.onNext，注意此时是在子线程执行。subscriber_D为ObserveOnSubscriber类型，那么接着看ObserveOnSubscriber的onNext
@Override
public void onNext(final T t) {
if (isUnsubscribed() || finished) {
return;
}
if (!queue.offer(on.next(t))) {
onError(new MissingBackpressureException());
return;
}
schedule();
}接着看schedule（）
protected void schedule() {
if (counter.getAndIncrement() == 0) {
recursiveScheduler.schedule(this);
}
}recursiveScheduler为Worker对象，recursiveScheduler.schedule(this)会把ObserveOnSubscriber.call放到主线程执行，那么接着看call函数
@Override
public void call() {
long missed = 1L;
long currentEmission = emitted;
// these are accessed in a tight loop around atomics so
// loading them into local variables avoids the mandatory re-reading
// of the constant fields
final Queue<Object> q = this.queue;
final Subscriber<? super T> localChild = this.child;
final NotificationLite<T> localOn = this.on;
// requested and counter are not included to avoid JIT issues with register spilling
// and their access is is amortized because they are part of the outer loop which runs
// less frequently (usually after each bufferSize elements)
for (;;) {
long requestAmount = requested.get();
while (requestAmount != currentEmission) {
boolean done = finished;
Object v = q.poll();
boolean empty = v == null;
if (checkTerminated(done, empty, localChild, q)) {
return;
}
if (empty) {
break;
}
localChild.onNext(localOn.getValue(v));
currentEmission++;
if (currentEmission == limit) {
requestAmount = BackpressureUtils.produced(requested, currentEmission);
request(currentEmission);
currentEmission = 0L;
}
}
if (requestAmount == currentEmission) {
if (checkTerminated(finished, q.isEmpty(), localChild, q)) {
return;
}
}
emitted = currentEmission;
missed = counter.addAndGet(-missed);
if (missed == 0L) {
break;
}
}
}直接看
localChild.onNext(localOn.getValue(v));localChild为subscriber_org对象。
@Override
public void onNext(String s) {
Log.e("Subscriber Thread id", ""+ Thread.currentThread().getId());
}看到这里整个主流程已走通,来个示意图
subscribeOn是在Observable.onSubscribe中完成线程切换，subscribeOn切换处于subscribeOn之前的调用链执行线程，so当多次subscribeOn调用的时候，只有最开始的subscribeOn有效。
observeOn是在subscriber对象中完成线程切换，observeOn切换处于observeOn之后的调用链执行线程。
doOnSubscribe默认发生在调用的subscribe线程。如果doOnSubscribe之后的调用链上有subscribeOn，那么doOnSubscribe的执行在subscribeOn切换的线程中（注意 doOnSubscribe之前的调用链上的subscribeOn不影响的doOnSubscribe）
线程相关
AndroidSchedulers.mainThread()
observeOn(AndroidSchedulers.mainThread()) public static Scheduler mainThread() {
return getInstance().mainThreadScheduler;
} private AndroidSchedulers() {
RxAndroidSchedulersHook hook = RxAndroidPlugins.getInstance().getSchedulersHook();
Scheduler main = hook.getMainThreadScheduler();
if (main != null) {
mainThreadScheduler = main;
} else {
mainThreadScheduler = new LooperScheduler(Looper.getMainLooper());
}
} LooperScheduler(Looper looper) {
handler = new Handler(looper);
}
observeOn中传入LooperScheduler对象，LooperScheduler构造函数中用主线程looper创建了一个handler。
observeOn线程切换是在ObserveOnSubscriber中完成的
this.recursiveScheduler = scheduler.createWorker(); @Override
public Worker createWorker() {
return new HandlerWorker(handler);
}scheduler为LooperScheduler对象，createWorker则会创建一个HandlerWorker对象
protected void schedule() {
if (counter.getAndIncrement() == 0) {
recursiveScheduler.schedule(this);
}
} @Override
public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) {
if (unsubscribed) {
return Subscriptions.unsubscribed();
}
action = hook.onSchedule(action);
ScheduledAction scheduledAction = new ScheduledAction(action, handler);
Message message = Message.obtain(handler, scheduledAction);
message.obj = this; // Used as token for unsubscription operation.
handler.sendMessageDelayed(message, unit.toMillis(delayTime));
if (unsubscribed) {
handler.removeCallbacks(scheduledAction);
return Subscriptions.unsubscribed();
}
return scheduledAction;
} ScheduledAction(Action0 action, Handler handler) {
this.action = action;
this.handler = handler;
}recursiveScheduler.schedule(this)中this为ObserveOnSubscriber对象，那么action为ObserveOnSubscriber对象。
接着创建了一个ScheduledAction对象。接着封装到message对象，并加入handler的MessageQueue中。
那么主线程会执行ScheduledAction的run方法
@Override public void run() {
try {
action.call();
} catch (Throwable e) {
// nothing to do but print a System error as this is fatal and there is nowhere else to throw this
IllegalStateException ie;
if (e instanceof OnErrorNotImplementedException) {
ie = new IllegalStateException("Exception thrown on Scheduler.Worker thread. Add `onError` handling.", e);
} else {
ie = new IllegalStateException("Fatal Exception thrown on Scheduler.Worker thread.", e);
}
RxJavaPlugins.getInstance().getErrorHandler().handleError(ie);
Thread thread = Thread.currentThread();
thread.getUncaughtExceptionHandler().uncaughtException(thread, ie);
}
}而run里面又调用action.call()，而action为ObserveOnSubscriber为对象,相当于调用ObserveOnSubscriber的call方法
@Override
public void call() {
......
localChild.onNext(localOn.getValue(v));
......
}localChild为subscribe传入的参数（subscribe_org）。那么subscribe_org.onNext将会在主线程执行。
Schedulers.io()
subscribeOn(Schedulers.io()) public void call(final Subscriber<? super T> subscriber) {
final Worker inner = scheduler.createWorker();
subscriber.add(inner);
inner.schedule(new Action0() {
@Override
public void call() {
final Thread t = Thread.currentThread();
Subscriber<T> s = new Subscriber<T>(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);
}
});
}同样Schedulers.io()调用createWorker创建了一个worker对象。然后worker调用schedule把action0加入到线程池中执行，Schedulers.io()实际是一个CachedThreadScheduler对象
public CachedThreadScheduler(ThreadFactory threadFactory) {
this.threadFactory = threadFactory;
this.pool = new AtomicReference<CachedWorkerPool>(NONE);
start();
}
@Override
public void start() {
CachedWorkerPool update =
new CachedWorkerPool(threadFactory, KEEP_ALIVE_TIME, KEEP_ALIVE_UNIT);
if (!pool.compareAndSet(NONE, update)) {
update.shutdown();
}
}
CachedThreadScheduler对象里面创建了一个线程池对象CachedWorkerPool
@Override
public Worker createWorker() {
return new EventLoopWorker(pool.get());
}
EventLoopWorker(CachedWorkerPool pool) {
this.pool = pool;
this.once = new AtomicBoolean();
this.threadWorker = pool.get();
}而createWorker返回了一个EventLoopWorker对象，EventLoopWorker的threadWorker 则为线程池对象
接着看worker的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;
}里面threadWorker.scheduleActual会把创建Action0加入线程任务队列里面。Action0的call方法将会子线程执行。call里面又调用action.call()
new Action0() {
@Override
public void call() {
final Thread t = Thread.currentThread();
Subscriber<T> s = new Subscriber<T>(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);
}那么subscribeOn(Schedulers.io())就分析完了
操作符
map
public final <R> Observable<R> map(Func1<? super T, ? extends R> func) {
return lift(new OperatorMap<T, R>(func));
}
public final <R> Observable<R> lift(final Operator<? extends R, ? super T> operator) {
return new Observable<R>(new OnSubscribeLift<T, R>(onSubscribe, operator));
}map会调用lift方法创建一个新的Observable对象
@Override
public Subscriber<? super T> call(final Subscriber<? super R> o) {
MapSubscriber<T, R> parent = new MapSubscriber<T, R>(o, transformer);
o.add(parent);
return parent;
}而在调用subscribe后，会调用OperatorMap的call方法返回一个新的Subscriber对象MapSubscriber。
@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);
}而MapSubscriber的onNext中会调用mapper.call(t)，mapper为map方法传入的对象（用于转换），actual.onNext(result)传给下一级Subscriber对象，result为转换后的类型
扫一扫
1009
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
