1 Rxjava2最簡單使用方式拆解
Observable p=Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) throws Exception {
e.onNext("hello world");
e.onComplete();
}
});public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
ObjectHelper.requireNonNull(source, "source is null");
return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
}調用create方法之後實際上返回了一個ObservableCreate對象.繼承了Observable,是一個被觀察者對象.
p.subscribe(new Observer() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Object value) {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});我們看下subscribe方法.
public final void subscribe(Observer<? super T> observer) {
...
subscribeActual(observer);
...
}
其他代碼都刪掉了,剩下最核心的 subscribeActual(observer),這個observer就是我們創建的匿名內部類對象.subscribeActual()方法是個抽象方法,我們看下ObservableCreate中是怎麼實現的.
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);
try {
source.subscribe(parent);
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
parent.onError(ex);
}
}CreateEmitter發射器,在這裏我們調用了 observer.onSubscribe(parent)也就是我們創建的匿名observer類的onSubscribe方法.
source.subscribe(parent)最重要的方法可能沒有之一,觀察者和被觀察者順利會師,事件開始執行,
@Override
public void subscribe(ObservableEmitter e) throws Exception {//這裏的ObservableEmitter就是parent,也就是CreateEmitter發射器對象
e.onNext("hello world");
e.onComplete();
}接下來看看CreateEmitter的onNext和onComplete方法.
@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()) {
observer.onNext(t);
}
}我們看到在發射器的onNext方法中,啥也沒做,就是當了個二傳手,調用了我們觀察者的onNext方法.
@Override
public void onComplete() {
if (!isDisposed()) {
try {
observer.onComplete();
} finally {
dispose();
}
}
}onComplete方法中也就是調用了觀察者的onComplete方法.
我們來縷縷這個過程
1 create方法傳返回了一個對象是ObservableCreate,ObservableCreate的構造方法中有一個ObservableOnSubscribe對象,也就是我們使用create時候創建的匿名內部類對象.
2 p.subscribe(o)實際上調用了ObservableCreate的subscribeActual方法
3 subscribeActual中首先調用了 observer的onSubscribe方法,緊接着調用了source.subscribe(parent)也就是ObservableOnSubscribe的subscribe方法,事件開始執行
4 subscribe方法中調用CreateEmitter的onNext方法,這個方法調用了observer的onNext方法,觀察者對事件進行反應.
5 subscribe方法中調用CreateEmitter的onComplete方法,這個方法調用了observer的onComplete方法,整個流程結束.
2 MAP操作符是怎麼工作的
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));
}map操作符把我們的observable對象變化成了具體的ObservableMap,參數是我們之前創建好的observable和mapper 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) {
source.subscribe(new MapObserver<T, U>(t, function));
}注意注意:這裏形成了一個新的訂閱關係
這裏的source是我們create創建的observable,要不然會懵,創建ObservableMap時候我們傳進來的this是我們生成的observable.
到這裏我們會重新調用onSubscribe() subscribeActual(),這裏就回到了我們最簡單模式時候的調用步驟.不同的是我們真正的調用observer的方法實在MapObserver對應的方法中.
具體流程是發射器調用onNext方法-->MapObserver的onNext方法-->再到我們定義的observer的onNext方法
@Override
public void onNext(T t) {
if (done) {
return;
}
if (sourceMode != NONE) {
actual.onNext(null);
return;
}
U v;
try {
//調用mapper改變數據
**v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");**
} catch (Throwable ex) {
fail(ex);
return;
}
//actual我們定義的observer
actual.onNext(v);
}3 進階flatMap
@SchedulerSupport(SchedulerSupport.NONE)
public final <R> Observable<R> flatMap(Function<? super T, ? extends ObservableSource<? extends R>> mapper,
boolean delayErrors, int maxConcurrency, int bufferSize) {
...
return RxJavaPlugins.onAssembly(new ObservableFlatMap<T, R>(this, mapper, delayErrors, maxConcurrency, bufferSize));看看ObservableFlatMap代碼
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) {
if (ObservableScalarXMap.tryScalarXMapSubscribe(source, t, mapper)) {
return;
}
source.subscribe(new MergeObserver<T, U>(t, mapper, delayErrors, maxConcurrency, bufferSize));
}是不是和MAP超級像,我們這幾看MergeObserver onNext做了什麼
@Override
public void onNext(T t) {
...
p = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper returned a null ObservableSource");
...
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++);
addInner(inner);
p.subscribe(inner);
break;
}
}
}
省略了很多代碼,我們看主要邏輯,獲取到flatMap生成的observableSource,然後 p.subscribe(inner);注意這裏的P不是observable
看innerObserver的onNext做了什麼
//這裏的onNext事件由 p.subscribe(inner)觸發
@Override
public void onNext(U t) {
if (fusionMode == QueueDisposable.NONE) {
parent.tryEmit(t, this);
} else {
parent.drain();
}
}
void tryEmit(U value, InnerObserver<T, U> inner) {
if (get() == 0 && compareAndSet(0, 1)) {
actual.onNext(value);
if (decrementAndGet() == 0) {
return;
}
} else {
SimpleQueue<U> q = inner.queue;
if (q == null) {
q = new SpscLinkedArrayQueue<U>(bufferSize);
inner.queue = q;
}
q.offer(value);
if (getAndIncrement() != 0) {
return;
}
}
drainLoop();
}在這裏我們終於看到我們定義的observer接收到了onNext事件
4 總結
Observable ObservableSource要分清楚,他們都有一個方法叫subscribe()
Observer Emitter分清楚,他們有共同的方法onNext() onError() onComplete()
否則話很容易暈頭轉向.
文章如有表述有錯誤,請指出,謝謝.