前言
一直对Rxjava的实现很好奇,这次刚好有时间就看下它的源码,并把其中的思路记录下来,加深印象。先是看了其它人的分析后自己又去看了源码,说实话源码还是蛮绕的,可能自己还是对观察者模式理解的不够深刻吧…
这次主要了解三点:
1. 知道源头(Observable)是如何将数据发送出去的。
2. 知道终点(Observer)是如何接收到数据的。
3. 何时将源头和终点关联起来的。
源码分析
我们先用一个最简单的例子来看,这个例子不包含线程切换和其它操作符:
Observable
.create(
object : ObservableOnSubscribe<Int> {
override fun subscribe(e: ObservableEmitter<Int>) {
Log.i("test", "开始发送:")
e.onNext(1)
Log.i("test","准备结束:")
e.onComplete()
}
}
)
.subscribe(
object : Observer<Int> {
override fun onComplete() {
Log.i("test", "结束")
}
override fun onSubscribe(d: Disposable) {
Log.i("test", "注册成功!")
}
override fun onNext(t: Int) {
Log.i("test", "获得发送的数据:" + t.toString())
}
override fun onError(e: Throwable) {
}
}
)
Log打印结果:
02-02 11:41:41.022 2602-2602/com.z2wenfa.innostic.main I/test: 注册成功!
02-02 11:41:41.022 2602-2602/com.z2wenfa.innostic.main I/test: 开始发送:
02-02 11:41:41.023 2602-2602/com.z2wenfa.innostic.main I/test: 获得发送的数据:1
02-02 11:41:41.023 2602-2602/com.z2wenfa.innostic.main I/test: 准备结束:
02-02 11:41:41.023 2602-2602/com.z2wenfa.innostic.main I/test: 结束
从Log日志我们已经能够看到执行的顺序了
先执行Observer
的onSubscribe(d: Disposable)
->
再执行ObservableOnSubscribe
的subscribe(e: ObservableEmitter<Int>)
->
然后使用ObservableEmitte
r执行onNext()
->Observer
的onNext(t: Int)
->
ObservableEmitter
的onComplete()
->Observer
的onComplete()
看完执行的顺序我们开始通过源码看下内部是怎么实现的,为了更好的理解执行流程,代码我进行了部分的精简,首先我们来看Observable的create()方法。
create(ObservableOnSubscribe source)解析
public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
......
return new ObservableCreate<T>(source);
}
从这里我们可以看到我们传入一个ObservableOnSubscribe对象返回一个ObservableCreate对象。来看下ObservableCreate的源码。
public final class ObservableCreate<T> extends Observable<T> {
final ObservableOnSubscribe<T> source;
public ObservableCreate(ObservableOnSubscribe<T> source) {
this.source = source;
}
@Override
protected void subscribeActual(Observer<? super T> observer) {
CreateEmitter<T> parent = new CreateEmitter<T>(observer);
observer.onSubscribe(parent);
source.subscribe(parent);
......
}
}
这里我们可以看到ObservableCreate的构造函数就是把ObservableOnSubscribe给保存下来,这样做的目的是为了延迟将数据发送源和终点关联起来,我们看到ObservableCreate其实还是继承的Observable类,所以在获得ObservableCreate实例后调用subscribe方法。
subscribe(Observer observer)解析
public final void subscribe(Observer<? super T> observer) {
......
subscribeActual(observer);
......
}
我们看到最终实际上调用的是subscribeActual(observer);我们再回头看下ObservableCreate的subscribeActual()方法。
@Override
protected void subscribeActual(Observer<? super T> observer) {
CreateEmitter<T> parent = new CreateEmitter<T>(observer);
......
source.subscribe(parent);
......
}
我们一行一行的看,这里我们通过传入的Observer对象创建了一个CreateEmitter对象,来看下CreateEmitter对象的源码:
static final class CreateEmitter<T>
extends AtomicReference<Disposable>
implements ObservableEmitter<T>, Disposable {
private static final long serialVersionUID = -3434801548987643227L;
final Observer<? super T> observer;
CreateEmitter(Observer<? super T> observer) {
this.observer = observer;
}
@Override
public void onNext(T t) {
......
if (!isDisposed()) {
observer.onNext(t);
}
}
@Override
public void onError(Throwable t) {
if (!tryOnError(t)) {
RxJavaPlugins.onError(t);
}
}
@Override
public boolean tryOnError(Throwable t) {
......
if (!isDisposed()) {
try {
observer.onError(t);
} finally {
dispose();
}
return true;
}
return false;
}
@Override
public void onComplete() {
if (!isDisposed()) {
try {
observer.onComplete();
} finally {
dispose();
}
}
}
......
}
通过源码能够看到首先判断时候isDisposed(),为True那么则不再执行后面的操作,如果为false再看,就是调用Observer相应的方法。这个ObservableEmitter还是一个包装类。
我们接着往下看,source.subscribe(parent);
,还记得当时保存到Observable中的ObservableOnSubscribe source吗?传入创建的ObservableEmitter调用它的subscribe(@NonNull ObservableEmitter<T> e)
这样我们就把Observable和Observer通过
ObservableEmitter这个适配器关联起来了,调用ObservableEmitter相应方法的同时,通知Observer执行对应的方法。
后言
经过源码分析之后,感觉自己是明白了点,但是能力有限,不知道写出来之后大家是否能够看的很明白,如果还有疑惑可以自己再多看看源码。