RxJava框架內部采用觀察者模式，基于事件流的鏈式調用、邏輯簡潔、使用簡單，在Android開發(fā)中被廣泛的使用。
簡單用例：
//創(chuàng)建被觀察者
Observable observable = Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> e) throws Exception {
e.onNext(0);
e.onNext(1);
e.onNext(2);
e.onNext(3);
}
});
//創(chuàng)建被觀察者
Observer observer = new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Integer integer) {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
};
//綁定觀察者和被觀察者
observable.subscribe(observer);
- 創(chuàng)建被觀察者。
- 創(chuàng)建觀察者。
- 觀察者訂閱被觀察者，連接雙方。
一、創(chuàng)建被觀察者
首先需要調用Observable的create()方法創(chuàng)建Observable對象。
//Observable.java
public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
ObjectHelper.requireNonNull(source, "source is null");
return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
}
Observable的create方法需要傳遞參數ObservableOnSubscribe。ObservableOnSubscribe是一個接口。
public interface ObservableOnSubscribe<T> {
void subscribe(@NonNull ObservableEmitter<T> e) throws Exception;
}
而ObservableOnSubscribe接口中的subscribe方法參數是ObservableEmitter， ObservableEmitter繼承了Emitter接口。
public interface ObservableEmitter<T> extends Emitter<T> {
void setDisposable(@Nullable Disposable d);
void setCancellable(@Nullable Cancellable c);
boolean isDisposed();
@NonNull
ObservableEmitter<T> serialize();
@Experimental
boolean tryOnError(@NonNull Throwable t);
}
public interface Emitter<T> {
void onNext(@NonNull T value);
void onError(@NonNull Throwable error);
void onComplete();
}
Emitter的英文翻譯是發(fā)射器，在這里我們可以理解為事件的生產者，調用Emitter#onNext()方法發(fā)送事件給觀察者。Emitter的onNext()、onError()、onComplete()與觀察者Observer的onNext()、onError()、onComplete()方法一一對應。
Observable#create()
再回到Observable.create()方法
這里要說一個Rxjava操作符的套路，Observable.create()會返回ObservableCreate對象，返回對象就是類+方法名，比如Observable.zip()方法就會返回ObservableZip對象。
//Observable.java
public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
ObjectHelper.requireNonNull(source, "source is null");
return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
}
新建ObservableCreate對象，然后調用RxJavaPlugins.onAssembly()方法返回Observable類型參數。
public final class ObservableCreate<T> extends Observable<T> {
final ObservableOnSubscribe<T> source;
public ObservableCreate(ObservableOnSubscribe<T> source) {
this.source = source;
}
}
- ObservableCreate構造函數需要傳遞一個ObservableOnSubscribe對象，ObservableCreate內部保存ObservableOnSubscribe為全局變量source。
- ObservableCreate繼承了Observable，創(chuàng)建ObservableCreate對象就是創(chuàng)建了Observable對象。
RxJavaPlugins#onAssembly()
@NonNull
public static <T> Observable<T> onAssembly(@NonNull Observable<T> source) {
//onObservableAssembly默認為空
Function<? super Observable, ? extends Observable> f = onObservableAssembly;
if (f != null) {
return apply(f, source);
}
return source;
}
RxJavaPlugins中的onObservableAssembly變量默認為空，所以onAssembly()方法是直接把參數source返回出去。
小結：創(chuàng)建被觀察者主要經過兩個步驟；
(1) 創(chuàng)建ObservableOnSubscribe實例對象；
(2) 把ObservableOnSubscribe對象傳遞給ObservableCreate的構造方法，創(chuàng)建ObservableCreate對象，把ObservableOnSubscribe對象作為全局變量source保存起來。
(3)把第二步創(chuàng)建的ObservableCreate對象返回出去。
二、創(chuàng)建觀察者
public interface Observer<T> {
void onSubscribe(@NonNull Disposable d);
void onNext(@NonNull T t);
void onError(@NonNull Throwable e);
void onComplete();
}
Observer只是一個接口，創(chuàng)建觀察者就是創(chuàng)建Observer的實例。
三、讓觀察者訂閱被觀察者，連接雙方。
observable.subscribe(observer);
1. 調用Observable的subscribe()方法
//Observable.java
@SchedulerSupport(SchedulerSupport.NONE)
@Override
public final void subscribe(Observer<? super T> observer) {
//非空判斷
ObjectHelper.requireNonNull(observer, "observer is null");
try {
...
subscribeActual(observer);
} catch (NullPointerException e) { // NOPMD
throw e;
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
// can't call onError because no way to know if a Disposable has been set or not
// can't call onSubscribe because the call might have set a Subscription already
RxJavaPlugins.onError(e);
NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
npe.initCause(e);
throw npe;
}
}
Observable.subscribe()方法也有一個套路，subscribe()最后都會調用Observable的派生類的subscribeActual()方法。
2. 調用subscribeActual(observer)方法。
subscribeActual()是Obserable的抽象方法，而上文有講到創(chuàng)建Obserable.create最后得到ObservableCreate對象。所以subscribeActual()會調用ObservableCreate對象的subscribeActual()方法。
//ObservableCreate.java
@Override
protected void subscribeActual(Observer<? super T> observer)
//創(chuàng)建CreateEmitter實例對象
CreateEmitter<T> parent = new CreateEmitter<T>(observer);
//回調observer的onSubscribe()方法
observer.onSubscribe(parent);
try {
//回調ObservableOnSubscribe的subscribe()方法
source.subscribe(parent);
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
parent.onError(ex);
}
}
2.1 首先通過傳遞observer參數創(chuàng)建CreateEmitter的實例?？匆幌翪reateEmitter這個類
static final class CreateEmitter<T>extends AtomicReference<Disposable> implements ObservableEmitter<T>, Disposable {
final Observer<? super T> observer;
CreateEmitter(Observer<? super T> observer) {
this.observer = observer;
}
@Override
public void onNext(T t) {
...
if (!isDisposed()) {
observer.onNext(t);//回調observer的onNext()方法
}
}
@Override
public void onError(Throwable t) {
//調用tryOnError回調observer的onError()方法
if (!tryOnError(t)) {
RxJavaPlugins.onError(t);
}
}
@Override
public boolean tryOnError(Throwable t) {
...
if (!isDisposed()) {
try {
observer.onError(t);//回調observer的onError()方法
} finally {
dispose();
}
return true;
}
return false;
}
@Override
public void onComplete() {
if (!isDisposed()) {
try {
observer.onComplete();;//回調observer的onComplete()方法
} finally {
dispose();
}
}
}
}
observer傳給CreateEmitter之后，賦值給全局變量observer。CreateEmitter繼承了ObservableEmitter接口，是ObservableEmitter的實現，CreateEmitter中onNext()、onError()、onComplete()方法被調用時會調用觀察者observer的同名方法。
2.2 調用observer的onSubscribe方法，說明observable.subscribe(observer)方法執(zhí)行時，觀察者observer的onSubscribe()方法就會馬上被回調。
2.3 執(zhí)行source.subscribe(parent)方法，source為ObservableOnSubscribe的實例，parent為CreateEmitter的實例，那么ObservableOnSubscribe的subscribe()方法會被回調。
Observable observable = Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> e) throws Exception {
e.onNext(0);
e.onNext(1);
e.onNext(2);
e.onNext(3);
}
});
source.subscribe(parent)方法的執(zhí)行，會通過調用ObservableEmitter的e變量執(zhí)行onNext方法，也就是執(zhí)行了CreateEmitter的onNext()方法，CreateEmitter的onNext方法內部會調用observer.onNext()方法。
到這里，RxJava的訂閱流程就分析完成了。
總結：
1、創(chuàng)建ObservableOnSubscribe對象。
2、把ObservableOnSubscribe對象傳遞給ObservableCreate的構造方法，創(chuàng)建ObservableCreate對象（即Obserable對象），把ObservableOnSubscribe對象作為全局變量source保存起來。
3、創(chuàng)建Observer對象。
4、執(zhí)行observable.subscribe(observer)連接觀察者和被觀察者，會調用ObservableCreate的subscribeActual方法。
5、把Observer對象傳遞給CreateEmitter的構造方法，創(chuàng)建CreateEmitter對象。
6、回調observer的onSubscribe()方法。
7、回調ObservableOnSubscribe的subscribe(ObservableEmitter<T> e)方法，參數為CreateEmitter對象；那么 e.onNext(0)方法就會調用CreateEmitter中的onNext()方法，然后回調observer的onNext()方法。
