RxJava初見

核心思想

  • 觀察者模式
  1. RxJava最核心的兩個東西是Observables（被觀察者，事件源）和Subscribers（觀察者）。Observables發(fā)出一系列事件，Subscribers處理這些事件。
  2. 一個Observable可以發(fā)出零個或者多個事件，直到結(jié)束或者出錯。每發(fā)出一個事件，就會調(diào)用它的Subscriber的onNext方法，最后調(diào)用Subscriber.onNext()或者Subscriber.onError()結(jié)束。
  3. 如果一個Observerble沒有任何的的Subscriber，那么這個Observable是不會發(fā)出任何事件的。

  • 異步

  • 鏈式調(diào)用

基本使用

創(chuàng)建與訂閱

  • 創(chuàng)建觀察者（事件處理）和被觀察者（事件源）
  • 訂閱
// 創(chuàng)建被觀察者
Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
    @Override
    public void call(Subscriber<? super String> subscriber) {
        subscriber.onNext("Hello, world!");
        subscriber.onCompleted();
    }
});

// 創(chuàng)建觀察者
Subscriber<String> subscriber = new Subscriber<String>() {
    @Override
    public void onCompleted() {

    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onNext(String s) {
        System.out.println(s);
        showMsg(s);
    }
};

// 訂閱事件
observable.subscribe(subscriber);

簡潔模式：

Observable<String> observable1 = Observable.just("你好！");
Action1<String> onNextAction = new Action1<String>() {
    @Override
    public void call(String s) {
        System.out.println(s);
        showMsg(s);
    }
};

observable1.subscribe(onNextAction);

變換

map()

它將一種數(shù)據(jù)類型變換為另一種數(shù)據(jù)類型
同數(shù)據(jù)類型：

// 同數(shù)據(jù)類型
Observable.just("Hello, world!")
.map(new Func1<String, String>() {
    @Override
    public String call(String s) {
        return s + " -fengmlo";
    }
})
.subscribe(new Action1<String>() {
    @Override
    public void call(String s) {
        System.out.println(s);
        showMsg(s);
    }
});

不同數(shù)據(jù)類型：

// 不同數(shù)據(jù)類型
Observable.just("你好！")
.map(new Func1<String, Integer>() {
    @Override
    public Integer call(String s) {
        return s.hashCode();
    }
})
.subscribe(new Action1<Integer>() {
    @Override
    public void call(Integer integer) {
        System.out.println(integer);
        showMsg(integer + "");
    }
});

多次變換：

// 多次變換
Observable.just("你好！")
.map(new Func1<String, Integer>() {
    @Override
    public Integer call(String s) {
        return s.hashCode();
    }
})
.map(new Func1<Integer, String>() {
    @Override
    public String call(Integer integer) {
        return Integer.toString(integer);
    }
})
.subscribe(new Action1<String>() {
    @Override
    public void call(String s) {
        System.out.println(s);
        showMsg(s);
    }
});

集合操作

from()

它接收一個集合作為輸入，然后每次輸出一個元素給subscriber

//集合操作
Observable.from(new String[]{"url1", "url2", "url3"})//它接收一個集合作為輸入，然后每次輸出一個元素給subscriber
.subscribe(new Action1<String>() {
    @Override
    public void call(String s) {
        System.out.println(s);
        showMsg(s);
    }
});

flatMap()

它接收一個Observable的輸出作為輸入，同時輸出另外一個Observable

query("Hello, world!")
.flatMap(new Func1<List<String>, Observable<String>>() {//flatMap()接收一個Observable的輸出作為輸入，同時輸出另外一個Observable。
    @Override
    public Observable<String> call(List<String> strings) {
        return Observable.from(strings);
    }
})
.subscribe(new Action1<String>() {
    @Override
    public void call(String s) {
        System.out.println(s);
        showMsg(s);
    }
});

現(xiàn)在假設有這么個函數(shù)：

Observable<List<String>> query(String text) {
    List<String> list = Arrays.asList(new String[]{"url1", "url2", "url3"});
    return Observable.just(list);
}

flatMap把一個Observable變成一堆Observable

query("Hello, world!")
.flatMap(new Func1<List<String>, Observable<String>>() {//flatMap()接收一個Observable的輸出作為輸入，同時輸出另外一個Observable。
    @Override
    public Observable<String> call(List<String> strings) {
        return Observable.from(strings);
    }
})
.subscribe(new Action1<String>() {
    @Override
    public void call(String s) {
        System.out.println(s);
        showMsg(s);
    }
});

flatMap把一個Observable變成一個Observable，可以用map替換

query("Hello, world!")
.flatMap(new Func1<List<String>, Observable<String>>() {//flatMap()接收一個Observable的輸出作為輸入，同時輸出另外一個Observable。
    @Override
    public Observable<String> call(List<String> strings) {
        return Observable.from(strings);
    }
})
.flatMap(new Func1<String, Observable<String>>() {
    @Override
    public Observable<String> call(String s) {
        return Observable.just(s+s);
    }
})
/* 與前一個flatMap功能一致
.map(new Func1<String, String>() {
    @Override
    public String call(String s) {
        return s+s;
    }
})
*/
.subscribe(new Action1<String>() {
    @Override
    public void call(String s) {
        System.out.println(s);
        showMsg(s);
    }
});

filter()

輸出和輸入相同的元素，并且會過濾掉那些不滿足檢查條件的

query("數(shù)據(jù)過濾")
.flatMap(new Func1<List<String>, Observable<String>>() {
    @Override
    public Observable<String> call(List<String> strings) {
        return Observable.from(strings);
    }
})
.filter(new Func1<String, Boolean>() {
    @Override
    public Boolean call(String s) {
        return !s.equals("url1");
    }
}) //filter()輸出和輸入相同的元素，并且會過濾掉那些不滿足檢查條件的。
.subscribe(new Action1<String>() {
    @Override
    public void call(String s) {
        showMsg(s);
    }
});

指定結(jié)果個數(shù)

query("數(shù)據(jù)過濾")
.flatMap(new Func1<List<String>, Observable<String>>() {
    @Override
    public Observable<String> call(List<String> strings) {
        return Observable.from(strings);
    }
})
.take(2) //take()輸出最多指定數(shù)量的結(jié)果。
.subscribe(new Action1<String>() {
    @Override
    public void call(String s) {
        showMsg(s);
    }
});

訂閱前對數(shù)據(jù)操作

//訂閱之前對數(shù)據(jù)進行操作
query("數(shù)據(jù)過濾")
.flatMap(new Func1<List<String>, Observable<String>>() {
    @Override
    public Observable<String> call(List<String> strings) {
        return Observable.from(strings);
    }
})
.take(2) //take()輸出最多指定數(shù)量的結(jié)果。
.doOnNext(new Action1<String>() {
    @Override
    public void call(String s) {
        // TODO: 2016/8/15 something
    }
}) //doOnNext()允許我們在每次輸出一個元素之前做一些額外的事情
.subscribe(new Action1<String>() {
    @Override
    public void call(String s) {
        showMsg(s);
    }
});

調(diào)度器

異步是RxJava最重要的特性之一，RxJava使用subscribeOn()和observeOn()來分別指定訂閱的線程和觀察的線程，訂閱的線程即獲取、處理數(shù)據(jù)的線程，觀察的線程則一般是對數(shù)據(jù)進行展示的線程
eg：

retrofitService.getImage(url)
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(bitmap -> myImageView.setImageBitmap(bitmap));

RxAndroid

AndroidSchedulers

retrofitService.getImage(url)
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(bitmap -> myImageView.setImageBitmap(bitmap));

AndroidObservable

AndroidObservable，它提供了跟多的功能來配合Android的生命周期。bindActivity()和bindFragment()方法默認使用AndroidSchedulers.mainThread()來執(zhí)行觀察者代碼，這兩個方法會在Activity或者Fragment結(jié)束的時候通知被觀察者停止發(fā)出新的消息。

AndroidObservable.bindActivity(this, retrofitService.getImage(url)) 
    .subscribeOn(Schedulers.io())
    .subscribe(bitmap -> myImageView.setImageBitmap(bitmap);

AndroidObservable.fromBroadcast()方法允許你創(chuàng)建一個類似BroadcastReceiver的Observable對象。下面的例子展示了如何在網(wǎng)絡變化的時候被通知到：

IntentFilter filter = new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION);
AndroidObservable.fromBroadcast(context, filter)
    .subscribe(intent -> handleConnectivityChange(intent));

ViewObservable

ViewObservable可以給View添加了一些綁定。如果你想在每次點擊view的時候都收到一個事件，可以使用ViewObservable.clicks()，或者你想監(jiān)聽TextView的內(nèi)容變化，可以使用ViewObservable.text()

ViewObservable.clicks(mCardNameEditText, false)
    .subscribe(view -> handleClick(view));

參考鏈接

深入淺出RxJava（一：基礎篇）
深入淺出RxJava(二：操作符)
深入淺出RxJava三--響應式的好處
深入淺出RxJava四-在Android中使用響應式編程

給 Android 開發(fā)者的 RxJava 詳解

最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務。

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容