- 第一步：創建被觀察者（observable）
Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
emitter.onNext(1);
emitter.onNext(2);
emitter.onNext(3);
emitter.onNext(4);
emitter.onComplete();
//ObservableEmitter為事件的發射器
}
});
- 第二步 創建觀察者（observer）
Observer<Integer> observer = new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.d("a","subscribe");
}
@Override
public void onNext(Integer integer) {
Log.d("a",""+integer);
}
@Override
public void onError(Throwable e) {
Log.d("a","error");
}
@Override
public void onComplete() {
Log.d("a","complete");
}
};
-
被觀察者與觀察者建立聯系
observable.subscribe(observer);
Rxjava的鏈式操作
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
emitter.onNext(1);
emitter.onNext(2);
emitter.onNext(3);
emitter.onComplete();
}
}).subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "subscribe");
}
@Override
public void onNext(Integer value) {
Log.d(TAG, "" + value);
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "error");
}
@Override
public void onComplete() {
Log.d(TAG, "complete");
}
});
-
RxJava的異步和鏈式編程
異步操作需要調用observeOn(AndroidSchedulers.mainThread())，observeOn是事件回調的線程，AndroidSchedulers.mainThread()一看就知道是主線程，
subscribeOn(Schedulers.io())，subscribeOn是事件執行的線程，Schedulers.io()是子線程，這里也可以用Schedulers.newThread()，只不過io線程可以重用空閑的線程，因此多數情況下 io()比newThread() 更有效率。
簡單的來說, subscribeOn() 指定的是上游發送事件的線程, observeOn() 指定的是下游接收事件的線程.
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
emitter.onNext("連載1");
emitter.onNext("連載2");
emitter.onNext("連載3");
emitter.onComplete();
}
})
.observeOn(AndroidSchedulers.mainThread())//回調在主線程
.subscribeOn(Schedulers.io())//執行在io線程
.subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
Log.e(TAG,"onSubscribe");
}
@Override
public void onNext(String value) {
Log.e(TAG,"onNext:"+value);
}
@Override
public void onError(Throwable e) {
Log.e(TAG,"onError="+e.getMessage());
}
@Override
public void onComplete() {
Log.e(TAG,"onComplete()");
}
});
- 異步的舉例2
沒有任何嵌套，邏輯依然簡潔
Observable.create(new ObservableOnSubscribe<Drawable>() {
@Override
public void subscribe(ObservableEmitter<Drawable> emitter) throws Exception {
for (int i=0;i<drawableRes.length;i++){
Drawable drawable=getResources().getDrawable(drawableRes[i]);
//第6個圖片延時3秒后架子
if (i==5){
sleep(3000);
}
//復制第7張圖片到sd卡
if (i==6){
Bitmap bitmap=((BitmapDrawable)drawable).getBitmap();
saveBitmap(bitmap,"test.png", Bitmap.CompressFormat.PNG);
}
//上傳到網絡
if (i==7){
updateIcon(drawable);
}
emitter.onNext(drawable);
}
}
}).subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer<Drawable>() {
@Override
public void accept(Drawable drawable) throws Exception {
//回調后在UI界面上展示出來
}
});
- 關于上下游所在線程的問題
多次指定上游的線程只有第一次指定的有效, 也就是說多次調用subscribeOn() 只有第一次的有效, 其余的會被忽略.
多次指定下游的線程是可以的, 也就是說每調用一次observeOn() , 下游的線程就會切換一次.
舉個例子:
observable.subscribeOn(Schedulers.newThread())
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.observeOn(Schedulers.io())
.subscribe(consumer);
-
操作符
- Map
Observable.create(new ObservableOnSubscribe<Integer>() { @Override public void subscribe(ObservableEmitter<Integer> emitter) throws Exception { emitter.onNext(1); emitter.onNext(2); emitter.onNext(3); } }).map(new Function<Integer, String>() { @Override public String apply(Integer integer) throws Exception { return "This is result " + integer; } }).subscribe(new Consumer<String>() { @Override public void accept(String s) throws Exception { Log.d(TAG, s); } });
將上游的Integer類型數據轉化為下游的字符串類型 - Map
flatMap
下游輸出數據無序性concatMap 下游數據數據有序
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
emitter.onNext(1);
emitter.onNext(2);
emitter.onNext(3);
}
}).concatMap(new Function<Integer, ObservableSource<String>>() {
@Override
public ObservableSource<String> apply(Integer integer) throws Exception {
final List<String> list = new ArrayList<>();
for (int i = 0; i < 3; i++) {
list.add("I am value " + integer);
}
return Observable.fromIterable(list).delay(10,TimeUnit.MILLISECONDS);
}
}).subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.d(TAG, s);
}
});
- zip(將兩個上游按照一定形式合并)同時可以結合切換線程（或者說指定線程）
Observable<Integer> observable1 = Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
Log.d(TAG, "emit 1");
emitter.onNext(1);
Thread.sleep(1000);
Log.d(TAG, "emit 2");
emitter.onNext(2);
Thread.sleep(1000);
Log.d(TAG, "emit 3");
emitter.onNext(3);
Thread.sleep(1000);
Log.d(TAG, "emit 4");
emitter.onNext(4);
Thread.sleep(1000);
Log.d(TAG, "emit complete1");
emitter.onComplete();
}
});
Observable<String> observable2 = Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
Log.d(TAG, "emit A");
emitter.onNext("A");
Thread.sleep(1000);
Log.d(TAG, "emit B");
emitter.onNext("B");
Thread.sleep(1000);
Log.d(TAG, "emit C");
emitter.onNext("C");
Thread.sleep(1000);
Log.d(TAG, "emit complete2");
emitter.onComplete();
}
});
Observable.zip(observable1, observable2, new BiFunction<Integer, String, String>() {
@Override
public String apply(Integer integer, String s) throws Exception {
return integer + s;
}
}).subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "onSubscribe");
}
@Override
public void onNext(String value) {
Log.d(TAG, "onNext: " + value);
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "onError");
}
@Override
public void onComplete() {
Log.d(TAG, "onComplete");
}
});
- sample
每隔指定的時間就從上游中取出一個事件發送給下游.但是這個方法有個缺點, 就是丟失了大部分的事件.
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
for (int i = 0; ; i++) {
emitter.onNext(i);
}
}
}).subscribeOn(Schedulers.io())
.sample(2, TimeUnit.SECONDS) //sample取樣
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.d(TAG, "" + integer);
}
});
- interval操作符發送Long型的事件, 從0開始, 每隔指定的時間就把數字加1并發送出來
- onBackpressureBuffer()
onBackpressureDrop()
onBackpressureLatest()
Flowable.interval(1, TimeUnit.MICROSECONDS).onBackpressureDrop()
- 零碎知識點
- 上游可以發送無限個onNext, 下游也可以接收無限個onNext.
- 當上游發送了一個onComplete后, 上游onComplete之后的事件將會繼續發送, 而下游收到onComplete事件之后將不再繼續接收事件.
- 當上游發送了一個onError后, 上游onError之后的事件將繼續發送, 而下游收到onError事件之后將不再繼續接收事件.
- 上游可以不發送onComplete或onError.
- 最為關鍵的是onComplete和onError必須唯一并且互斥, 即不能發多個onComplete, 也不能發多個onError, 也不能先發一個onComplete, 然后再發一個onError, 反之亦然
