RxJava2 源码分析笔记(二)
上一篇文章: RxJava2 源码分析笔记(一)
下一篇文章:RxJava2 源码分析笔记(三) 线程切换
下面来看一个复杂一点的调用是如何工作的
AStudent aStudent = new AStudent();//我自己建的类
aStudent.setName(" dog ");
Observable
.just(aStudent)
.map(new Function() {
@Override
public String apply(@NonNull AStudent student) throws Exception {
String name = student.getName();
return name;
}
})
.flatMap(new Function>() {
@Override
public Observable apply(@NonNull String s) throws Exception {
List list = new ArrayList();
list.add(" i add " + s);
return Observable.fromIterable(list);
}
})
.subscribe(new Consumer() {
@Override
public void accept(String s) throws Exception {
System.out.println(" subscribe " + s);
}
}); 1
Observable .just 点进源码发现返回的是ObservableJust
.map 返回的是ObservableMap
.flatMap 返回的是ObservableFlatMap
ObservableJust,ObservableMap,ObservableFlatMap： 都直接或间接继承了Observable；都自己实现了subscribeActual方法；
源码
.just
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public static Observable just(T item) {
ObjectHelper.requireNonNull(item, "The item is null");
return RxJavaPlugins.onAssembly(new ObservableJust(item));//ObservableJust
} .map
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public final Observable map(Function mapper) {
ObjectHelper.requireNonNull(mapper, "mapper is null");
return RxJavaPlugins.onAssembly(new ObservableMap(this, mapper));//ObservableMap
} .flatmap(多点几下最后点到这里)
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public final Observable flatMap(Function> mapper,
boolean delayErrors, int maxConcurrency, int bufferSize) {
ObjectHelper.requireNonNull(mapper, "mapper is null");
ObjectHelper.verifyPositive(maxConcurrency, "maxConcurrency");
ObjectHelper.verifyPositive(bufferSize, "bufferSize");
if (this instanceof ScalarCallable) {
@SuppressWarnings("unchecked")
T v = ((ScalarCallable)this).call();
if (v == null) {
return empty();
}
return ObservableScalarXMap.scalarXMap(v, mapper);
}
return RxJavaPlugins.onAssembly(new ObservableFlatMap(this, mapper, delayErrors, maxConcurrency, bufferSize));//ObservableFlatMap
} 然后就变成了这样
到最后一步subscribe的时候首先调用的是ObservableFlatMap中的subscribeActual
那就看一下ObservableFlatMap源码
public final class ObservableFlatMap extends AbstractObservableWithUpstream {
final Function> mapper;
final boolean delayErrors;
final int maxConcurrency;
final int bufferSize;
public ObservableFlatMap(ObservableSource source,
Function> mapper,
boolean delayErrors, int maxConcurrency, int bufferSize) {
super(source);
this.mapper = mapper;
this.delayErrors = delayErrors;
this.maxConcurrency = maxConcurrency;
this.bufferSize = bufferSize;
}
@Override
public void subscribeActual(Observer t) {
...
//核心代码
// MergeObserver 实现了Observer，这个对象作用很大
//他的构造函数传入了t, 也就是我们自己指定的Oberver
//也就是说它利用我们自己创建的Oberver新建了一个自己的Observer对象
source.subscribe(new MergeObserver(t, mapper, delayErrors, maxConcurrency, bufferSize));
} 执行的是 source.subscribe( new MergeObserver
这个source是构造函数中传入的
public ObservableFlatMap(ObservableSource source,
Function> mapper,
boolean delayErrors, int maxConcurrency, int bufferSize) {
super(source);
this.mapper = mapper;
this.delayErrors = delayErrors;
this.maxConcurrency = maxConcurrency;
this.bufferSize = bufferSize;
} 构造函数是在 .flatMap时候调用的
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public final Observable flatMap(Function> mapper,
boolean delayErrors, int maxConcurrency, int bufferSize) {
...省略其它代码...
//这个this是什么呢，就是谁.flatMap;根据上面是ObservableMap.flatMap
return RxJavaPlugins.onAssembly(new ObservableFlatMap(this, mapper, delayErrors, maxConcurrency, bufferSize));
} 这样source就找到了是前面的ObservableMap，
source.subscribe 等于 ObservableMap.subscribe ，并将自己创建的MergeObserver传到ObservableMap中
这样就变成了下图
这样就是
ObservableMap.subscribe真实调用的就是ObservableMap中的subscribeActual方法
接着就看ObservableMap的源码
public final class ObservableMap extends AbstractObservableWithUpstream {
final Function function;
public ObservableMap(ObservableSource source, Function function) {
super(source);
this.function = function;
}
@Override
public void subscribeActual(Observer t) {
//他也是利用传进来的Observer创建了自己新的Observer对象MapObserver
//并subcribe到上一层
source.subscribe(new MapObserver(t, function));
} 看到ObservabelMap的源码感觉很熟悉，同样的 source.subscribe
是的这个source就是前面的 ObservableJust，这样就将自己创建的MapObserver传到ObservableJust中
现在到了 ObservableJust.subscribe 就是执行ObservableJust中的subscribeActual 方法
ObservableJust源码
public final class ObservableJust extends Observable implements ScalarCallable {
//这里的value就是 Observable.just(aStudent)中的aStudent对象
//这里赋值并会传递下去
private final T value;
public ObservableJust(final T value) {
this.value = value;
}
@Override
protected void subscribeActual(Observer s) {
ScalarDisposable sd = new ScalarDisposable(s, value);
s.onSubscribe(sd);
sd.run();
} 终于不一样了，我们来到了数据源这里，接下来就是把数据怎么传回去了
核心代码是 sd.run();
注意：
这样一些列subscribe都会传递一个Observer到上一层
我们自己自创建的 observer ——> MergeObserver ——> MapObserver
他们都实现了Observer,并利用前一个Observer创建自己的对象。
我们接着来看 sd.run();
ScalarDisposable源码
public static final class ScalarDisposable
extends AtomicInteger
implements QueueDisposable, Runnable {
// 这个Observer就是 MapObserver
final Observer observer;
...省略其他代码.......
public ScalarDisposable(Observer observer, T value) {
this.observer = observer;
this.value = value;
}
@Override
public void run() {
if (get() == START && compareAndSet(START, ON_NEXT)) {
//即 MapObserver.onNext
//value就是aStudent
observer.onNext(value);
if (get() == ON_NEXT) {
lazySet(ON_COMPLETE);
observer.onComplete();
}
}
}
在run中核心是调用了MapObserver.onNext
接着就看下MapObserver的源码
static final class MapObserver extends BasicFuseableObserver {
final Function mapper;
MapObserver(Observer actual, Function mapper) {
//这个actual就是上一个传进来的MergeObserver
// actual变量位置在其父类BasicFuseableObserver
//本质就是使用传进来的MergeObserver
super(actual);
this.mapper = mapper;
}
@Override
public void onNext(T t) {
...代码省略...
U v;
try {
//还记得我们在.map中return student.getName();
// .map(new Function() {
// @Override
// public String apply(@NonNull AStudent student) throws Exception {
// String name = student.getName();
// return name;
// }
// })
// mapper.apply(t) 就是调用了 apply(@NonNull AStudent student)
// t就是ObservableJust传过来的astudent对象
v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
} catch (Throwable ex) {
fail(ex);
return;
}
//真实调用就是MergeObserver.onNext
actual.onNext(v);
} 核心就是 MergeObserver.onNext 接下来就看一下MergeObserver的源码
static final class MergeObserver extends AtomicInteger implements Disposable, Observer {
// actual 就是我们自己创建的Observer
final Observer actual;
MergeObserver(Observer actual, Function> mapper,
boolean delayErrors, int maxConcurrency, int bufferSize) {
this.actual = actual;
...其他代码省略...
}
@Override
public void onSubscribe(Disposable s) {
if (DisposableHelper.validate(this.s, s)) {
this.s = s;
actual.onSubscribe(this);
}
}
@Override
public void onNext(T t) {
try {
//因为这是FlatMap,通过apply， return的值
//t就是前面传过来的aStudent的name的值
// .flatMap(new Function>() {
// @Override
// public Observable apply(@NonNull String s) throws Exception {
// List list = new ArrayList();
// list.add(" i add " + s);
// return Observable.fromIterable(list);
// }
// })
// mapper.apply(t)就是apply(@NonNull String s)
p = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper returned a null ObservableSource");
} catch (Throwable e) {
return;
}
// step1
subscribeInner(p);
}
@SuppressWarnings("unchecked")
void subscribeInner(ObservableSource p) {
for (;;) {
if (p instanceof Callable) {
//这里p不是Callable
} else {
InnerObserver inner = new InnerObserver(this, uniqueId++);
if (addInner(inner)) {
// step2
p.subscribe(inner);
}
break;
}
}
} 现在走到了
p.subscribe(inner);
p: 在最开始的地方我们在flatMap中return了一个
Observable.fromIterable(list)inner: InnerObserver
所以
p.subscribe(inner) = Observable.fromIterable(list).subscribe(inner);
有没有感觉很熟悉，这不就是另外一个Observable .......到最后subscribe.
Observable.fromIterable(list)其实就是一个ObservableFromIterable对象
ObservableFromIterable.subscribe(inner)本质就是调用ObservableFromIterable的subscribeActual
那就看ObservableFromIterable源码
public final class ObservableFromIterable extends Observable {
//source就是fromIterable(list)传进来的list
final Iterable source;
public ObservableFromIterable(Iterable source) {
this.source = source;
}
@Override
public void subscribeActual(Observer s) {
Iterator it;
//用source生成数据
it = source.iterator();
//s就是传进来的inner
FromIterableDisposable d = new FromIterableDisposable(s, it);
s.onSubscribe(d);
if (!d.fusionMode) {
//核心代码
d.run();
}
}
现在到了d.run(); d就是FromIterableDisposable，并将inner和数据it传了进去
static final class FromIterableDisposable extends BasicQueueDisposable {
final Observer actual;
final Iterator it;
// actual就是inner; it 就是那个list数据
FromIterableDisposable(Observer actual, Iterator it) {
this.actual = actual;
this.it = it;
}
void run() {
boolean hasNext;
do {
...
try {
//这里就是循环取list中的数据
v = ObjectHelper.requireNonNull(it.next(), "The iterator returned a null value");
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
actual.onError(e);
return;
}
//核心代码
//即 inner.onNext(数值)
actual.onNext(v);
....
} while (hasNext);
if (!isDisposed()) {
actual.onComplete();
}
} 终于到了 inner.onNext 并带着数值
static final class InnerObserver extends AtomicReference
implements Observer {
final long id;
final MergeObserver parent;
InnerObserver(MergeObserver parent, long id) {
this.id = id;
this.parent = parent;
}
@Override
public void onNext(U t) {
if (fusionMode == QueueDisposable.NONE) {
//核心代码
// t 上一步传过来的数值，再传到tryEmit中
parent.tryEmit(t, this);
} else {
parent.drain();
}
}
void tryEmit(U value, InnerObserver inner) {
if (get() == 0 && compareAndSet(0, 1)) {
.....
//核心代码
actual.onNext(value);
} else {
.....
}
drainLoop();
}
你点一下发现 actual 是位于 MergeObserver 中，因为InnerObserver就是MergeObserver的一个内部类；
而actual就是我们自己创建的Observer
Observer.onNext(value)就是
Observable
.just(aStudent)
.map(...)
.flatMap(...)
.subscribe(new Observer() {
@Override
public void onSubscribe(@NonNull Disposable d) {
}
@Override
public void onNext(@NonNull String s) {
数值终于回调到这里了
}
@Override
public void onError(@NonNull Throwable e) {
}
@Override
public void onComplete() {
}
});
这样整个调用流程就走完了。
大体流程就是Observable.create/just/from开始不停地创建Obserable的各种子类都实现了 subscribeActual ，直到最后subcribe了一个Observer,然后开始回调前一个Obserable的subscribeActual，而在subscribeActual方法中会有一个source.subscribe(...);这样就会一直回调上一个Obserable的subscribeActual，并同时将自己创建的Observer(构造函数都会用前一个Observer作为参数)传到前一个Obserable中，直到 create/just/from 开始利用一直传过来的Observer进行传值，最后传到我们自己的Observer中，我们就拿到了值。
===========================================================
文章开始的时候我在subscribe中传入的是Consumer
Observable
.just(aStudent)
.map(new Function() {
@Override
public String apply(@NonNull AStudent student) throws Exception {
String name = student.getName();
return name;
}
})
.flatMap(new Function>() {
@Override
public Observable apply(@NonNull String s) throws Exception {
List list = new ArrayList();
list.add(" i add " + s);
return Observable.fromIterable(list);
}
})
.subscribe(new Consumer() {
@Override
public void accept(String s) throws Exception {
System.out.println(" subscribe " + s);
}
}); Consumer是怎么回调的oNext,它并没有这个方法
点进源码一直点到最后，原来我们传入的Consumer会被转化成LambdaObserver
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public final Disposable subscribe(Consumer onNext, Consumer onError,
Action onComplete, Consumer onSubscribe) {
........
// onNext 就是我们传进来的Consumer，其他参数是源码中自动帮我们添加的值
LambdaObserver ls = new LambdaObserver(onNext, onError, onComplete, onSubscribe);
subscribe(ls);
return ls;
} 那就再看LambdaObserver源码
public final class LambdaObserver extends AtomicReference
implements Observer, Disposable, LambdaConsumerIntrospection {
final Consumer onNext;
public LambdaObserver(Consumer onNext, Consumer onError,
Action onComplete,
Consumer onSubscribe) {
super();
this.onNext = onNext;
this.onError = onError;
this.onComplete = onComplete;
this.onSubscribe = onSubscribe;
}
@Override
public void onNext(T t) {
if (!isDisposed()) {
try {
//核心代码
onNext.accept(t);
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
get().dispose();
onError(e);
}
}
} 在onNext中调用了 Consumer.accept 就是我们传入的对象的回调。