Previous article: RxJava2 source code analysis notes (1)
Next article: RxJava2 source code analysis notes (3) thread switching
Let’s see how a more complicated call works
AStudent aStudent = new AStudent();//我自己建的类
aStudent.setName(" dog ");
Observable
.just(aStudent)
.map(new Function<AStudent, String>() {
@Override
public String apply(@NonNull AStudent student) throws Exception {
String name = student.getName();
return name;
}
})
.flatMap(new Function<String, Observable<String>>() {
@Override
public Observable<String> apply(@NonNull String s) throws Exception {
List<String> list = new ArrayList();
list.add(" i add " + s);
return Observable.fromIterable(list);
}
})
.subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
System.out.println(" subscribe " + s);
}
});1
Observable .just Click into the source code and find that the return is ObservableJust
.map returns ObservableMap
.flatMap returns ObservableFlatMap
ObservableJust, ObservableMap, ObservableFlatMap: All directly or indirectly inherit Observable; they all implement the subscribeActual method themselves;
Source code
.just
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public static <T> Observable<T> just(T item) {
ObjectHelper.requireNonNull(item, "The item is null");
return RxJavaPlugins.onAssembly(new ObservableJust<T>(item));//ObservableJust
}.map
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
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
}.flatmap (a few more clicks and finally click here)
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public final <R> Observable<R> flatMap(Function<? super T, ? extends ObservableSource<? extends R>> 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<T>)this).call();
if (v == null) {
return empty();
}
return ObservableScalarXMap.scalarXMap(v, mapper);
}
return RxJavaPlugins.onAssembly(new ObservableFlatMap<T, R>(this, mapper, delayErrors, maxConcurrency, bufferSize));//ObservableFlatMap
}Then it became like this
In the last step of subscribe, the first call is subscribeActual in ObservableFlatMap
Then take a look at the ObservableFlatMap source code
public final class ObservableFlatMap<T, U> extends AbstractObservableWithUpstream<T, U> {
final Function<? super T, ? extends ObservableSource<? extends U>> mapper;
final boolean delayErrors;
final int maxConcurrency;
final int bufferSize;
public ObservableFlatMap(ObservableSource<T> source,
Function<? super T, ? extends ObservableSource<? extends U>> 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<? super U> t) {
...
//核心代码
// MergeObserver 实现了Observer，这个对象作用很大
//他的构造函数传入了t, 也就是我们自己指定的Oberver
//也就是说它利用我们自己创建的Oberver新建了一个自己的Observer对象
source.subscribe(new MergeObserver<T, U>(t, mapper, delayErrors, maxConcurrency, bufferSize));
}The implementation is source.subscribe( new MergeObserver<T, U>( ...) );
This source is passed in in the constructor
public ObservableFlatMap(ObservableSource<T> source,
Function<? super T, ? extends ObservableSource<? extends U>> mapper,
boolean delayErrors, int maxConcurrency, int bufferSize) {
super(source);
this.mapper = mapper;
this.delayErrors = delayErrors;
this.maxConcurrency = maxConcurrency;
this.bufferSize = bufferSize;
}The constructor is called when .flatMap
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public final <R> Observable<R> flatMap(Function<? super T, ? extends ObservableSource<? extends R>> mapper,
boolean delayErrors, int maxConcurrency, int bufferSize) {
...省略其它代码...
//这个this是什么呢，就是谁.flatMap;根据上面是ObservableMap.flatMap
return RxJavaPlugins.onAssembly(new ObservableFlatMap<T, R>(this, mapper, delayErrors, maxConcurrency, bufferSize));
}In this way, the source finds the ObservableMap in front,
source.subscribe is equal to ObservableMap.subscribe and passes the MergeObserver created by yourself to ObservableMap
This becomes the following picture
This is
ObservableMap.subscribeThe actual call is the subscribeActual method in ObservableMap
Then look at the source code of ObservableMap
public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {
final Function<? super T, ? extends U> function;
public ObservableMap(ObservableSource<T> source, Function<? super T, ? extends U> function) {
super(source);
this.function = function;
}
@Override
public void subscribeActual(Observer<? super U> t) {
//他也是利用传进来的Observer创建了自己新的Observer对象MapObserver
//并subcribe到上一层
source.subscribe(new MapObserver<T, U>(t, function));
}Seeing the source code of ObservabelMap feels very familiar, the same source.subscribe
Yes, this source is the previous ObservableJust, so you can pass the MapObserver you created to ObservableJust
Now to ObservableJust.subscribe is to execute the subscribeActual method in ObservableJust
ObservableJust source code
public final class ObservableJust<T> extends Observable<T> implements ScalarCallable<T> {
//这里的value就是 Observable.just(aStudent)中的aStudent对象
//这里赋值并会传递下去
private final T value;
public ObservableJust(final T value) {
this.value = value;
}
@Override
protected void subscribeActual(Observer<? super T> s) {
ScalarDisposable<T> sd = new ScalarDisposable<T>(s, value);
s.onSubscribe(sd);
sd.run();
}Finally it’s different, we came to the data source, the next step is how to transfer the data back
The core code is sd.run();
note:
In this way, some columns of subscribe will pass an Observer to the upper layer
Our self-created observer ——> MergeObserver ——> MapObserver
They all implement Observer and use the previous Observer to create their own objects.
Let's look at sd.run();
ScalarDisposable source code
public static final class ScalarDisposable<T>
extends AtomicInteger
implements QueueDisposable<T>, Runnable {
// 这个Observer就是 MapObserver
final Observer<? super T> observer;
...省略其他代码.......
public ScalarDisposable(Observer<? super T> 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();
}
}
}
The core of the run is to call MapObserver.onNext
Then look at the source code of MapObserver
static final class MapObserver<T, U> extends BasicFuseableObserver<T, U> {
final Function<? super T, ? extends U> mapper;
MapObserver(Observer<? super U> actual, Function<? super T, ? extends U> 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<AStudent, String>() {
// @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 Next, take a look at the source code of MergeObserver
static final class MergeObserver<T, U> extends AtomicInteger implements Disposable, Observer<T> {
// actual 就是我们自己创建的Observer
final Observer<? super U> actual;
MergeObserver(Observer<? super U> actual, Function<? super T, ? extends ObservableSource<? extends U>> 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<String, Observable<String>>() {
// @Override
// public Observable<String> apply(@NonNull String s) throws Exception {
// List<String> 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<? extends U> p) {
for (;;) {
if (p instanceof Callable) {
//这里p不是Callable
} else {
InnerObserver<T, U> inner = new InnerObserver<T, U>(this, uniqueId++);
if (addInner(inner)) {
// step2
p.subscribe(inner);
}
break;
}
}
}Now it's here
p.subscribe(inner);
p: At the very beginning, we returned one in flatMap
Observable.fromIterable(list)inner: InnerObserver
and so
p.subscribe(inner) = Observable.fromIterable(list).subscribe(inner);
Do you feel familiar? Isn't this another Observable... until the end subscribe.
Observable.fromIterable(list) is actually an ObservableFromIterable object
ObservableFromIterable.subscribe(inner) essentially calls the subscribeActual of ObservableFromIterable
Then look at the ObservableFromIterable source code
public final class ObservableFromIterable<T> extends Observable<T> {
//source就是fromIterable(list)传进来的list
final Iterable<? extends T> source;
public ObservableFromIterable(Iterable<? extends T> source) {
this.source = source;
}
@Override
public void subscribeActual(Observer<? super T> s) {
Iterator<? extends T> it;
//用source生成数据
it = source.iterator();
//s就是传进来的inner
FromIterableDisposable<T> d = new FromIterableDisposable<T>(s, it);
s.onSubscribe(d);
if (!d.fusionMode) {
//核心代码
d.run();
}
}
Now it’s d.run(); d is FromIterableDisposable, and the inner and data it is passed in
static final class FromIterableDisposable<T> extends BasicQueueDisposable<T> {
final Observer<? super T> actual;
final Iterator<? extends T> it;
// actual就是inner; it 就是那个list数据
FromIterableDisposable(Observer<? super T> actual, Iterator<? extends T> 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();
}
}Finally arrived inner.onNext with the value
static final class InnerObserver<T, U> extends AtomicReference<Disposable>
implements Observer<U> {
final long id;
final MergeObserver<T, U> parent;
InnerObserver(MergeObserver<T, U> 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<T, U> inner) {
if (get() == 0 && compareAndSet(0, 1)) {
.....
//核心代码
actual.onNext(value);
} else {
.....
}
drainLoop();
}
You click and find that actual is located in MergeObserver, because InnerObserver is an internal class of MergeObserver;
And actual is the Observer we created ourselves
Observer.onNext(value) is
Observable
.just(aStudent)
.map(...)
.flatMap(...)
.subscribe(new Observer<String>() {
@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() {
}
});
This completes the call flow.
The general process is that Observable.create/just/from starts to create various subclasses of Obserable all the way to implement subscribeActual, until finally subcribe an Observer, and then begin to call back the subscribeActual of the previous Obserable, and there will be one in the subscribeActual method source.subscribe(...); This will always call back the subscribeActual of the previous Obserable, and at the same time pass the Observer you created (the constructor will use the previous Observer as a parameter) to the previous Obserable until create/just/ From began to use the Observer that has been passed to pass the value, and finally passed to our own Observer, we got the value.
===========================================================
At the beginning of the article, I passed Consumer in subscribe
Observable
.just(aStudent)
.map(new Function<AStudent, String>() {
@Override
public String apply(@NonNull AStudent student) throws Exception {
String name = student.getName();
return name;
}
})
.flatMap(new Function<String, Observable<String>>() {
@Override
public Observable<String> apply(@NonNull String s) throws Exception {
List<String> list = new ArrayList();
list.add(" i add " + s);
return Observable.fromIterable(list);
}
})
.subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
System.out.println(" subscribe " + s);
}
});How does Consumer callback oNext, it does not have this method
Clicking into the source code until the end, the Consumer we passed in will be converted into LambdaObserver
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
Action onComplete, Consumer<? super Disposable> onSubscribe) {
........
// onNext 就是我们传进来的Consumer，其他参数是源码中自动帮我们添加的值
LambdaObserver<T> ls = new LambdaObserver<T>(onNext, onError, onComplete, onSubscribe);
subscribe(ls);
return ls;
}Then look at the LambdaObserver source code
public final class LambdaObserver<T> extends AtomicReference<Disposable>
implements Observer<T>, Disposable, LambdaConsumerIntrospection {
final Consumer<? super T> onNext;
public LambdaObserver(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
Action onComplete,
Consumer<? super Disposable> 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);
}
}
}Calling Consumer.accept in onNext is the callback of the object we passed in.