Rxjava2流程初探
目标
- 了解Rxjava2 同步执行的基本流程
例子
先解释一下2个函数的作用：
- map是将一个数据源中每个数据转成另外一种类型。
- flatmap用于将一个数据源中的每个数据，转成一个新的数据源的被观察者。
看一个简单的例子：
class Penson{
val pList : ArrayList<Plan> = ArrayList()
}
class Plan {
var plan : Int = 0
}
//造一些数据
val personList = ArrayList<Penson>()
for(z in 0..2){
val penson = Penson()
for (x in 0..3){
val plan = Plan()
plan.plan = x
penson.pList.add(plan)
}
personList.add(penson)
}
//开始运行rxjava
Observable.fromIterable(personList).flatMap{
Observable.fromIterable(it.pList)
}.map{
"I'm plan :"+it.plan
}.subscribe(object:Observer<String>{
override fun onComplete() {
}
override fun onSubscribe(d: Disposable) {
}
override fun onNext(t: String) {
println("打印"+t)
}
override fun onError(e: Throwable) {
}
})
通过这个例子来梳理一下Rxjava2的流程：
- 通过原始数据创建最上游的被观察者A ObservableFromIterable 。
public static <T> Observable<T> fromIterable(Iterable<? extends T> source) {
ObjectHelper.requireNonNull(source, "source is null");
return RxJavaPlugins.onAssembly(new ObservableFromIterable<T>(source));
}
- 被观察者A创建被观察者B ObservableFlatMap ，被观察者B持有被观察者A的引用。
public final <R> Observable<R> flatMap(Function<? super T, ? extends ObservableSource<? extends R>> mapper,
boolean delayErrors, int maxConcurrency, int bufferSize) {
...
if (this instanceof ScalarCallable) {
...
}
return RxJavaPlugins.onAssembly(new ObservableFlatMap<T, R>(this, mapper, delayErrors, maxConcurrency, bufferSize));
}
- 被观察者B创建被观察者C ObservableMap，被观察者C持有被观察者B的引用。
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));
}
-
被观察者C调用subscribe函数，传入最下游的观察者。
-
subscribe函数是Observable中的一个final方法，最后会执行Observable的subscribeActual方法，subscribeActual是一个抽象方法，具体实现在每个Observable子类。
//Observable.java
public final void subscribe(Observer<? super T> observer) {
ObjectHelper.requireNonNull(observer, "...");
try {
observer = RxJavaPlugins.onSubscribe(this, observer);
ObjectHelper.requireNonNull(observer, "");
subscribeActual(observer);
} catch (NullPointerException e) { // NOPMD
throw e;
} catch (Throwable e) {
...
}
}
protected abstract void subscribeActual(Observer<? super T> observer);
- 执行被观察C的subscribeActual，它调用上游被观察者B的subscribe方法并传入一个新的观察者MapObserver，姑且叫做观察者C。观察者C对最下游观察者进行引用。
//ObservableMap.java
@Override
public void subscribeActual(Observer<? super U> t) {
source.subscribe(new MapObserver<T, U>(t, function));
}
- 执行被观察者B的subscribeActual，它调用上游被观察者A的subscribe方法并传入一个新的观察者MergeObserver，姑且叫做观察者B。观察者B对下游观察者C进行引用。
//ObservableFlatMap.java
@Override
public void subscribeActual(Observer<? super U> t) {
if (ObservableScalarXMap.tryScalarXMapSubscribe(source, t, mapper)) {
return;
}
source.subscribe(new MergeObserver<T, U>(t, mapper, delayErrors, maxConcurrency, bufferSize));
}
- 执行被观察者A的subscribeActual，创建一个FromIterableDisposable对象并且运行run方法，从原始数据中循环取出数据并返回给下游观察者B。
//ObservableFromIterable.java
public void subscribeActual(Observer<? super T> observer) {
Iterator<? extends T> it;
try {
it = source.iterator();
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
EmptyDisposable.error(e, observer);
return;
}
boolean hasNext;
try {
hasNext = it.hasNext();
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
EmptyDisposable.error(e, observer);
return;
}
if (!hasNext) {
EmptyDisposable.complete(observer);
return;
}
FromIterableDisposable<T> d = new FromIterableDisposable<T>(observer, it);
observer.onSubscribe(d);
if (!d.fusionMode) {
d.run();
}
}
static final class FromIterableDisposable<T> extends BasicQueueDisposable<T> {
final Observer<? super T> downstream;
final Iterator<? extends T> it;
volatile boolean disposed;
boolean fusionMode;
boolean done;
boolean checkNext;
FromIterableDisposable(Observer<? super T> actual, Iterator<? extends T> it) {
this.downstream = actual;
this.it = it;
}
void run() {
boolean hasNext;
do {
if (isDisposed()) {
return;
}
T v;
try {
v = ObjectHelper.requireNonNull(it.next(), "The iterator returned a null value");
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
downstream.onError(e);
return;
}
downstream.onNext(v);
if (isDisposed()) {
return;
}
try {
hasNext = it.hasNext();
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
downstream.onError(e);
return;
}
} while (hasNext);
if (!isDisposed()) {
downstream.onComplete();
}
}
}
- 在下游观察者B的onNext函数中，通过Function.apply函数将原始数据转成一个新的数据源的被观察者B2，就是上面flatMap中返回的Observable.fromIterable(it.pList)。用一个持有观察者B的引用的内部观察者InnerObserver对被观察者B2进行订阅，执行到InnerObserver的onNext时，再通过观察者B取出下游观察者C执行。
//MergeObserver.java
@Override
public void onNext(T t) {
// safeguard against misbehaving sources
if (done) {
return;
}
ObservableSource<? extends U> p;
try {
p = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper returned a null ObservableSource");
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
upstream.dispose();
onError(e);
return;
}
if (maxConcurrency != Integer.MAX_VALUE) {
synchronized (this) {
if (wip == maxConcurrency) {
sources.offer(p);
return;
}
wip++;
}
}
subscribeInner(p);
}
@SuppressWarnings("unchecked")
void subscribeInner(ObservableSource<? extends U> p) {
for (;;) {
if (p instanceof Callable) {
...
} else {
InnerObserver<T, U> inner = new InnerObserver<T, U>(this, uniqueId++);
if (addInner(inner)) {
p.subscribe(inner);
}
break;
}
}
}
- 在下游观察者C的onNext函数中， 通过Function.apply函数将数据转成新的类型，然后调用最下游的观察者。
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) {
super(actual);
this.mapper = mapper;
}
@Override
public void onNext(T t) {
if (done) {
return;
}
if (sourceMode != NONE) {
downstream.onNext(null);
return;
}
U v;
try {
v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
} catch (Throwable ex) {
fail(ex);
return;
}
downstream.onNext(v);
}
}
总结
- Rxjava2从源数据开始一层层往下创建被观察者，最底层的被观察者调用subscribe订阅时，再从底层被观察者调用上一层被观察者的订阅方法，同时传入该层对应的观察者。来到最上层被观察者订阅时，再把源数据逐一返回给下一层观察者以完成整个流程。
- 每一层的被观察者都对应一个该层的观察者。
- 数据在流动的过程中，可以像flatMap那样创建一个新的被观察者取代原来的上层被观察者。
4987
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
