Android響應式程式設計之RxJava2.0
前言
優點:
1、鏈式操作
2、非同步優化
實戰
先來個簡單的使用示例
Observable
.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
e.onNext("1" );
e.onNext("2");
e.onComplete();
}
})
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(String s) {
Log.d(TAG, "onNext: " + s);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
Log.d(TAG, "onComplete: ");
}
});
輸出Log
onNext: 1
onNext: 2
onComplete:
專案依賴
dependencies {
// RxJava
compile 'io.reactivex.rxjava2:rxjava:2.0.8'
compile 'io.reactivex.rxjava2:rxandroid:2.0.1'
compile 'com.trello.rxlifecycle2:rxlifecycle:2.0.1'
compile 'com.trello.rxlifecycle2:rxlifecycle-android:2.0.1'
compile 'com.jakewharton.rxbinding2:rxbinding:2.0.0'
}
執行緒排程器,用於靈活的切換執行緒,RxJava內建主要提供了以下幾個,基本夠用了
Schedulers.io() 代表io操作的執行緒, 通常用於網路,讀寫檔案等io密集型的操作
Schedulers.computation() 代表CPU計算密集型的操作, 例如需要大量計算的操作
Schedulers.newThread() 代表一個常規的新執行緒
AndroidSchedulers.mainThread() 代表Android的主執行緒
操作符
變換操作
Map
簡單的說就是中間轉換層,把被觀察者傳送的資料->進行轉換後->再發送給觀察者接收。
用例項來證明
Observable
.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(@NonNull ObservableEmitter<Integer> e) throws Exception {
Log.d(TAG, "onNext: 1");
e.onNext(1);
Log.d(TAG, "onNext: 2");
e.onNext(2);
}
})
.map(new Function<Integer, String>() {
@Override
public String apply(@NonNull Integer integer) throws Exception {
Log.d(TAG, "apply: map");
return "format to string " + integer;
}
})
.subscribe(new Consumer<String>() {
@Override
public void accept(@NonNull String s) throws Exception {
Log.d(TAG, "accept: " + s);
}
});
輸出Log
onNext: 1
apply: map
accept: format to string 1
onNext: 2
accept: format to string 2
FlagMap
將一個傳送事件的Observable變換生成新的一個或多個傳送事件的Observable,再發送。
注意:合併後傳送順序是無序的。
用實踐來證明
Observable
.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(@NonNull ObservableEmitter<Integer> e) throws Exception {
Log.d(TAG, "onNext: 1");
e.onNext(1);
Log.d(TAG, "onNext: 2");
e.onNext(2);
}
})
.flatMap(new Function<Integer, ObservableSource<String>>() {
@Override
public ObservableSource<String> apply(@NonNull Integer integer) throws Exception {
Log.d(TAG, "apply: flatMap");
List<String> list = new ArrayList<String>();
for (int i = 0; i < 3; i++) {
list.add("format to string " + integer);
}
return Observable.fromIterable(list);
}
})
.subscribe(new Consumer<String>() {
@Override
public void accept(@NonNull String s) throws Exception {
Log.d(TAG, "accept: " + s);
}
});
輸出Log
onNext: 1
apply: flatMap
accept: format to string 1
format to string 1
accept: format to string 1
onNext: 2
apply: flatMap
accept: format to string 2
accept: format to string 2
accept: format to string 2
ConcatMap
根FlatMap基本一樣,唯一區別就是傳送順序是有序的。
Zip
將多個傳送事件的Observable,合併生成一個新的傳送事件的Observable,再發送。
注意:合併順序是嚴格按照發送順序來的,並且生成的新的傳送事件數量,取傳送事件數量最少的那個,這個應該可以理解。
用例項來證明
Observable obb1 = Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
Log.d(TAG, "onNext: A");
e.onNext("A");
Log.d(TAG, "onNext: B");
e.onNext("B");
Log.d(TAG, "onNext: C");
e.onNext("C");
Log.d(TAG, "onNext: D");
e.onNext("D");
}
}).subscribeOn(Schedulers.io());
Observable obb2 = Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(@NonNull ObservableEmitter<Integer> e) throws Exception {
Log.d(TAG, "onNext: 1");
e.onNext(1);
Log.d(TAG, "onNext: 2");
e.onNext(2);
Log.d(TAG, "onNext: 3");
e.onNext(3);
}
}).subscribeOn(Schedulers.io());
Observable
.zip(obb1, obb2, new BiFunction<String, Integer, String>() {
@Override
public String apply(@NonNull String s, @NonNull Integer integer) throws Exception {
Log.d(TAG, "apply: zip");
return s + "+" + integer;
}
})
.subscribe(new Consumer<String>() {
@Override
public void accept(@NonNull String s) throws Exception {
Log.d(TAG, "accept: " + s);
}
});
輸出Log
onNext: A
onNext: B
onNext: C
onNext: D
onNext: 1
apply: zip
accept: A+1
onNext: 2
apply: zip
accept: B+2
onNext: 3
apply: zip
accept: C+3
……
未完待續