Rxjava是一種響應式編程實現,響應式編程就是定義業務邏輯關係
比如正常的編程b = a + 1;這個是一個指令。執行到這裏的時候,b的值已經被計算出來了
如果b <= a + 1;這是定義b和a的關係,具體的值還沒有,直到 a.onNext(1);
Rxjava 訂閱和事件分發機制
Rxjava其實就是一個通過Observable的subcribe向上通知和onNext向下彙報事件的過程,最後交給observer處理。
具體調用流程如下:
1.public final Disposable subscribe(Consumer<? super T> onNext)
2.public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError)
3.public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
Action onComplete, Consumer<? super Disposable> onSubscribe)
4.public final void subscribe(Observer<? super T> observer);
上面1~3的接口會被封裝爲Observer的LambdaObserver,然後調用4.subscribe(Observer<? super T> observer),
Rxjava鏈式調用
由於RXjava支持鏈式調用,從而讓observable形成一個observable雙向鏈表,Observable的source引用上一個Observable,並創建一個observer給上一個Observable引用,從而使得上一個obserable能夠回調回來,形成向上的鏈條,進而形成一個雙向鏈表。
具體到一個案例:
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> e) throws Exception {
e.onNext(1);
e.onNext(2);
e.onNext(3);
}
}).map(new Function<Integer, Student>() {
@Override
public Student apply(Integer id) throws Exception {
return new Student(id);
}
}).flatMap(new Function<Student, ObservableSource<Course>>() {
@Override
public ObservableSource<Course> apply(Student student) throws Exception {
return Observable.just(new Course("math", student), new Course("eng", student));
}
}).lift(new ObservableOperator<String, Course>(){
@Override
public Observer<? super Course> apply(final Observer<? super String> actual) {
return new Observer<Course>() {
@Override
public void onSubscribe(Disposable d) {
actual.onSubscribe(d);
}
@Override
public void onComplete() {
actual.onComplete();
}
@Override
public void onError(Throwable e) {
actual.onError(e);
}
@Override
public void onNext(Course course) {
actual.onNext(course.getScore());
}
};
}
}).subscribe(new Consumer<String>() {
@Override
public void accept(String score) throws Exception {
}
});
我們來分段分析:
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> e) throws Exception {
e.onNext(1);
e.onNext(2);
e.onNext(3);
}
}).map(new Function<Integer, Student>() {
@Override
public Student apply(Integer id) throws Exception {
return new Student(id);
}
}).flatMap(new Function<Student, ObservableSource<Course>>() {
@Override
public ObservableSource<Course> apply(Student student) throws Exception {
return Observable.just(new Course("math", student), new Course("eng", student));
}
}).lift(new ObservableOperator<String, Course>(){
@Override
public Observer<? super Course> apply(final Observer<? super String> actual) {
return new Observer<Course>() {
@Override
public void onSubscribe(Disposable d) {
actual.onSubscribe(d);
}
@Override
public void onComplete() {
actual.onComplete();
}
@Override
public void onError(Throwable e) {
actual.onError(e);
}
@Override
public void onNext(Course course) {
actual.onNext(course.getScore());
}
};
}
})
在調用subscrible之前,只構造了source這個單向鏈表
當執行最後面的subscribe
.subscribe(new Consumer<String>() {
@Override
public void accept(String score) throws Exception {
}
});
會從下到上一直調用subscrible直到最頂層的ObservableOnSubscribe的subscrible
new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> e) throws Exception {
//這個函數是最後一個subscribe
e.onNext(1);
e.onNext(2);
e.onNext(3);
}
}
subscrible這個向上調用的過程就是構造Observer的過程,會構造每一層的ObserverWrap,比如最先構造OperatorObserver,最後構造CreateEmitter。
然後下面的代碼會從上往下一路調用前面構造的Observer.
public void subscribe(ObservableEmitter<Integer> e) throws Exception {
//如果我們將這個e保存爲全局變量,就可以在任意地點任意時間激發事件了
e.onNext(1);
e.onNext(2);
e.onNext(3);
}
調用圖如下:
concatMap如何保證事件的時序
我們知道flatmap和concatMap都支持新增observable發射新的事件, 但是flatmap沒法保證時序,而concatMap保證時序
concatmap保證時序的原因是它每次調用Obserable.subscribe後會等到onSubscribe調用onComplete,然後纔會調用下一個Obserable.subscribe,從而保證了時序。
具體源碼如下:
class SourceObserver {
@Override
public void onNext(T t) {
if (done) {
return;
}
if (fusionMode == QueueDisposable.NONE) {
//先都放在隊列
queue.offer(t);
}
//只能一個一個處理
drain();
}
void drain() {
if (getAndIncrement() != 0) {
return;
}
for (;;) {
if (disposed) {
queue.clear();
return;
}
//保證了只能一個一個處理
if (!active) {
boolean d = done;
T t;
try {
t = queue.poll();
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
dispose();
queue.clear();
downstream.onError(ex);
return;
}
boolean empty = t == null;
if (d && empty) {
disposed = true;
downstream.onComplete();
return;
}
if (!empty) {
ObservableSource<? extends U> o;
active = true;
o.subscribe(inner);
}
}
if (decrementAndGet() == 0) {
break;
}
}
}
InnerObserver {
@Override
public void onComplete() {
parent.innerComplete();
}
}
void innerComplete() {
active = false;
//drain會執行下一個source.subscribe
drain();
}
附錄
Rxjava是一個鏈式數據處理的框架,且通過observable和observer兩種鏈接組件,能夠將其他observable和observer像搭積木的方式組合成複雜的功能,實現模塊化和解耦合的效果。
Rxjava的常用操作
/**************************************************
* 本文來自CSDN博主"一點碼客",喜歡請頂部點擊關注
* 轉載請標明出處:http://blog.csdn.net/itchosen
***************************************************/
如需實時查看更多更新文章,請關注公衆號"一點碼客",一起探索技術