概述
RxJava是一个用于使用可观察的序列组合异步和基于事件的程序的库,其主要是用于异步的、可线程切换的、可观察序列事件,那么这个事件序列倒是是什么样的?(注:RxJava版本:2.2.7)
目的
1.事件序列是怎么形成的
2.事件的流向
分析
分析的代码
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
Log.d("RxJava:", "subscribe:");
emitter.onNext(1);
emitter.onComplete();
}
}).map(new Function<Integer, String>() {
@Override
public String apply(Integer integer) throws Exception {
Log.d("RxJava:", "map1:");
return integer.toString();
}
}).map(new Function<String, String>() {
@Override
public String apply(String s) throws Exception {
Log.d("RxJava:", "map2:");
return s;
}
}).subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(String s) {
Log.d("RxJava:", "onNext:");
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
运行结果:
2020-01-07 17:17:51.527 20237-20237/com.wkkun.litho D/RxJava:: subscribe:
2020-01-07 17:17:51.527 20237-20237/com.wkkun.litho D/RxJava:: map1:
2020-01-07 17:17:51.527 20237-20237/com.wkkun.litho D/RxJava:: map2:
2020-01-07 17:17:51.527 20237-20237/com.wkkun.litho D/RxJava:: onNext:
首先分析操作符map
Observable.class
@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));
}
RxJavaPlugins.onAssembly()前面已经分析过了是hook函数,默认不实现,可忽略,
所以此处返回 new ObservableMap<T, R>(this, mapper)
ObservableMap类
public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {...}
ObservableMap继承AbstractObservableWithUpstream所以先看下类AbstractObservableWithUpstream
AbstractObservableWithUpstream类
abstract class AbstractObservableWithUpstream<T, U> extends Observable<U>
implements HasUpstreamObservableSource<T> {
/** The source consumable Observable. */
protected final ObservableSource<T> source;
/**
* Constructs the ObservableSource with the given consumable.
* @param source the consumable Observable
*/
AbstractObservableWithUpstream(ObservableSource<T> source) {
//构造函数 保存给定的ObservableSource
this.source = source;
}
@Override
public final ObservableSource<T> source() {
return source;
}
}
AbstractObservableWithUpstream代码很简单就是构造函数保存了给定的ObservableSource对象,
但是需要注意的是该类继承Observable,所以ObservableMap也是一个Observable实例
接着获取看ObservableMap类
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) {
//1
super(source);
this.function = function;
}
@Override
public void subscribeActual(Observer<? super U> t) {
//2
source.subscribe(new MapObserver<T, U>(t, function));
}
...
}
上述1处,调用父类的构造函数,存储ObservableSource,而前面我们看到 map方法的实现是
Observable{
...
public final <R> Observable<R> map(Function<? super T, ? extends R> mapper){
return new ObservableMap<T, R>(this, mapper);
}
...
}
所以ObservableMap会存储调用map方法的Observable实例,
上述2处 我们知道ObservableMap是一个Observable实例,
所以实现Observable的抽象方法subscribeActual(详细的我们在第一篇中已经说过了)
subscribeActual方法中,使用存储的Observable实例进行订阅包装后的Observer
我们接着先看下MapObserver类,在回头总结
MapObserver类
//BasicFuseableObserver继承与Observer
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存储为downstream(父类的构造函数)
super(actual);
//存储转换的函数
this.mapper = mapper;
}
@Override
public void onNext(T t) {
//在onError 和onComplete方法中会设置 done = true
if (done) {
return;
}
//上述分析的代码中 sourceMode请求到的都是NONE
if (sourceMode != NONE) {
downstream.onNext(null);
return;
}
U v;
try {
//调用存储的Function方法对传进来的参数t进行转换为v
v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
} catch (Throwable ex) {
fail(ex);
return;
}
//调用下游的onNext(v)
downstream.onNext(v);
}
//先行忽略 分析的代码中requestFusion请求得到都是NONE
@Override
public int requestFusion(int mode) {
return transitiveBoundaryFusion(mode);
}
//先行忽略 上述分析的代码不会调用
@Nullable
@Override
public U poll() throws Exception {
T t = qd.poll();
return t != null ? ObjectHelper.<U>requireNonNull(mapper.apply(t), "The mapper function returned a null value.") : null;
}
}
我们现在先主要关注 事件流的 调用 先行忽略未用到的关于QueueFuseable方面的内容,后面的文章会详细的说明
**
现在我们得到了关于map操作符的大致流程
**
1.生成一个ObservableMap并存储调用map的Observable上流数据源
2.subscribe(Observer)订阅
3.包装Observer生成new MapObserver<T, U>(Observer, function),当调用onNext(T t)应用给定的转换函数
4.使用存储的Observable调用subscribe(Observer)方法,即是source.subscribe(new MapObserver<T, U>(t, function));
现在map的大概流程分析,接下来模拟最上面代码整个事件的流程
整个代码流程:
new ObservableMap<T, R>(new ObservableMap<T, R>(new ObservableCreate<T>(new ObservableOnSubscribe(){}), Function mapper), Function mapper).subscribe(new Observer(){})
回调订阅流程如下:
ObservableCreate.subscribe(new MapObserver<T, U>((new MapObserver<T, U>(new new Observer(){}, function),function));
一步步拆分
生成Observable过程,最终生成Observable C
Observable A = new ObservableCreate<T>(new ObservableOnSubscribe(){})
Observable B = new ObservableMap<T, R>(A, Function mapper)
Observable C = new ObservableMap<T, R>(B, Function mapper)
订阅过程
Observer D = new Observer(){}
C.subscribe(D)
拆分C.subscribe(D),最终生成一个经过两个包装的Observer,然后源发射源进行订阅该Observer
C.subscribe(D)
->内部调用
Observer E =new MapObserver<T, U>(D, function)
B.subscribe(E)
->内部调用
A.subscribe(new MapObserver<T, U>(E, function))
整个代码流程:
通过上面的分析可以得到,每个操作符既是一个观察者,订阅上面的数据流,也是一个被观察者,发送经过其处理的数据源,
所以:RxJava形成的可观察事件序列,除了首尾,中间事件节点,都是既是观察者又是被观察者,其向上订阅,向下分发数据,
我们可以将RxJava形成的事件序列可称为数据流,数据从最初的Observable流向最后的Observer,
所以可以称最初的Observable为上游,最后的Observer为下游
总结:
1.RxJava形成的可观察事件序列是一个数据流,最初的Observable为上游,最后的Observer为下游
2.数据从上游流向下流,订阅从下游向上游订阅
3.数据流中间节点,每一个节点既是观察者也是被观察者