Rxjava2源码分析(一)
- 看源码的前期工作
- 想了解源码解决了什么问题,就着重去想这些问题。
- rxjava如何顺序执行的,即时是新开了线程,也是顺序执行了。
- rxjava怎么切换线程的。
- rxjava取消之后为什么后续不会执行了。
- 看源码要由整体到局部,由局部到细节,由简单到复杂。
- 看的过程有所记录,免得遗忘,也可以画结构图。
- 想了解源码解决了什么问题,就着重去想这些问题。
程序入口
Observable.create(new ObservableOnSubscribe<ArrayList<String>>() {
@Override
public void subscribe(ObservableEmitter<ArrayList<String>> emitter) throws Exception {
ArrayList<String>stringArrayList=new ArrayList<>();
stringArrayList.add("hello");
emitter.onNext(stringArrayList);
Log.i("msg1","上游事件线程"+Thread.currentThread());
}
}).doOnNext(new Consumer<ArrayList<String>>() {
@Override
public void accept(ArrayList<String> s) throws Exception {
Log.i("msg1","第1个线程开始执行"+Thread.currentThread());
s.add("第一个");
}
}).doOnNext(new Consumer<ArrayList<String>>() {
@Override
public void accept(ArrayList<String> s) throws Exception {
Log.i("msg1","第2个线程开始执行"+Thread.currentThread());
s.add("第二个");
}
}).doOnNext(new Consumer<ArrayList<String>>() {
@Override
public void accept(ArrayList<String> s) throws Exception {
Log.i("msg1","第3个线程开始执行"+Thread.currentThread());
s.add("第三个");
}
}).subsc.subscribe(new Observer<ArrayList<String>>() {
@Override
public void onSubscribe(Disposable d) {
d.dispose();
}
@Override
public void onNext(ArrayList<String> s) {
Log.i("msg1","下游事件线程"+Thread.currentThread());
Log.i("msg1","第四个线程"+s.toString());
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
我们先看Observable.create()方法
public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
ObjectHelper.requireNonNull(source, "source is null");
//最终返回一个ObservableCreate类,并且将ObservableOnSubscribe参数传入构造函数中
return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
}
我们来看ObservableCreate类
public final class ObservableCreate<T> extends Observable<T> {
final ObservableOnSubscribe<T> source;
public ObservableCreate(ObservableOnSubscribe<T> source) {
this.source = source;
}
……
}
可以看到Observable.create()方法其实就是生成ObservableCreate类,保存一个ObservableOnSubscribe引用,并且将ObservableCreate作为返回值。
再继续往下看doOnNext(new Consumer())方法
private Observable<T> doOnEach(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Action onAfterTerminate) {
……
return RxJavaPlugins.onAssembly(new ObservableDoOnEach<T>(this, onNext, onError, onComplete, onAfterTerminate));
}
}
doOnNext方法最终返回一个ObservableDoOnEach,并且将ObservableCreate,Consumer类传入它的构造函数中
public final class ObservableDoOnEach<T> extends AbstractObservableWithUpstream<T, T> {
final Consumer<? super T> onNext;
final Consumer<? super Throwable> onError;
final Action onComplete;
final Action onAfterTerminate;
public ObservableDoOnEach(ObservableSource<T> source, Consumer<? super T> onNext,
Consumer<? super Throwable> onError,
Action onComplete,
Action onAfterTerminate) {
super(source);
this.onNext = onNext;
this.onError = onError;
this.onComplete = onComplete;
this.onAfterTerminate = onAfterTerminate;
}
……
}
abstract class AbstractObservableWithUpstream<T, U> extends Observable<U> implements HasUpstreamObservableSource<T> {
protected final ObservableSource<T> source;
AbstractObservableWithUpstream(ObservableSource<T> source) {
this.source = source;
}
}
从上面代码可以看出ObservableCreate被赋值为父类的成员变量source,Consumer类被保存到onNext成员变量中,如果下面继续调用两个doOnNext()那么会形成如下结构。
之后再看subscribe(Observer)方法,要看ObservableDoOnEach的subscribe方法,因为最后返回的是ObservableDoOnEach类。ObservableDoOnEach的subscribe方法在Observable中,Observable是它的父类,它没有重写该方法。
public final void subscribe(Observer<? super T> observer) {
ObjectHelper.requireNonNull(observer, "observer is null");
try {
observer = RxJavaPlugins.onSubscribe(this, observer);
ObjectHelper.requireNonNull(observer, "The RxJavaPlugins.onSubscribe hook returned a null Observer.
subscribeActual(observer);
} catch (NullPointerException e) { // NOPMD
throw e;
} catch (Throwable e) {
……
}
}
// 该方法执行了subscribeActual(observer)方法,那我们来看ObservableDoOnEach的subscribeActual方法。
@Override
public void subscribeActual(Observer<? super T> t) {
source.subscribe(new DoOnEachObserver<T>(t, onNext, onError, onComplete, onAfterTerminate));
}
// 这里是执行source的subscribe方法,并且将DoOnEachObserver类作为参数传入。
static final class DoOnEachObserver<T> implements Observer<T>, Disposable {
final Observer<? super T> downstream;
final Consumer<? super T> onNext;
final Consumer<? super Throwable> onError;
final Action onComplete;
final Action onAfterTerminate;
Disposable upstream;
boolean done;
DoOnEachObserver(
Observer<? super T> actual,
Consumer<? super T> onNext,
Consumer<? super Throwable> onError,
Action onComplete,
Action onAfterTerminate) {
this.downstream = actual;
this.onNext = onNext;
this.onError = onError;
this.onComplete = onComplete;
this.onAfterTerminate = onAfterTerminate;
}
……
}
// 这里是一个递归调用,一直到ObservableCreate执行subscribeActual方法
protected void subscribeActual(Observer<? super T> observer) {
CreateEmitter<T> parent = new CreateEmitter<T>(observer);
observer.onSubscribe(parent);
try {
source.subscribe(parent);
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
parent.onError(ex);
}
}
这里生成一个CreateEmitter,将observer作为参数传入
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;
}
}
// 接着执行ObservableDoOnEach的subscribe方法
public void onSubscribe(Disposable d) {
if (DisposableHelper.validate(this.upstream, d)) {
this.upstream = d;
downstream.onSubscribe(this);
}
}
这里就是给ObservableDoOnEach的upstream 逐一赋值赋值,就变成一个双向的链表了。
接着执行source.subscribe(parent)也就是
下面是以上代码形成的结构图
调用source.subscribe之后,上面的示例代码执行了emitter.onNext(T value)方法。
@Override
public void onNext(T t) {
if (t == null) {
onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
return;
}
if (!isDisposed()) {
//如果没有取消,那么就会执行下面的onNext方法,如果取消了,就不会往下执行了,这里肯定是逐步往下执行了
observer.onNext(t);
}
}
//DoOnEachObserver的onNext方法,接着调用downstream的onNext方法。
@Override
public void onNext(T t) {
if (done) {
return;
}
try {
onNext.accept(t);
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
upstream.dispose();
onError(e);
return;
}
downstream.onNext(t);
}
这里可以回答上面的两个问题,第一个问题是如何顺序执行的,这里是一个双向链表结构,执行完该链表的方法会继续向下执行,还有一个问题是取消之后不会向下执行,那是因为,每一步执行之前都会检查是否取消了,如果取消,那么就不会继续执行了。
下面是rxjava2源码分析(二)链接: https://blog.csdn.net/qq_43676395/article/details/104877903.