android 從Rxjava2.0到Retrofit (一)

前言:遺憾的我現在才發現這2個框架驚人之處.現在學學還不算完,但Rxjava真的很難入手,不想okhttp,Retrofit那樣看下就可以使用,所以學習Rxjava還需要一段蠻長時間.


Rxjava從1.x到2.x,方法和類都有很多改變,但是功能還是那個樣,剛剛學習有太多的不解.對於1.x的,,我也沒用過,直接從2.x開始擼起,

Rxjava是什麼呢?可以理解爲異步的框架. 類似於 AsyncTask. 但其靈活性和擴展性遠遠強於前者


主要包過這幾個接口:

Publisher 
Subscriber 
Subscription 
Processor 
Flowable與Observable


publisher和processor我還沒用過,後面將去使用再更新.

subsrcipiton,Flowable,observable,observer,subscriber則是重點.

Subscriber 和 Observer的接口是分別獨立的,Obsesrver用於訂閱Observable,而Subscriber用於訂閱Flowable


Rxjava可以理解爲觀察者模式,觀察者模式不知道什麼?最好的理解就是我們Android中Button的點擊事0件:


觀察者(OnClickListener接口),被觀察者(Buttion的底層觸摸事件),訂閱(setOnClickListener()方法)

對應

觀察者(Observable或Flowable),被觀察者(Observer或Subscriber),訂閱(subscribe()方法)


接下來我們看一個例子:



//創建一個被觀察者
Observable<String> observable=Observable.create(new ObservableOnSubscribe<String>() {
    @Override
    public void subscribe(ObservableEmitter<String> e) throws Exception {
	//觸發被觀察者的一個事件
        System.out.println("2,subscribe");
        e.onNext("observable");
        e.onComplete();
    }
});
//訂閱被觀察者的行爲事件
observable.subscribe(new Observer<String>() {
    @Override
    public void onSubscribe(Disposable d)
    {
        System.out.println("1,當訂閱事件後首先執行的是onSubscribe--");

    }

    @Override
    public void onNext(String value) {
        System.out.println("4,onNext--");
    }

    @Override
    public void onError(Throwable e) {
        System.out.println("onError--");
    }

    @Override
    public void onComplete() {
        System.out.println("5,onComplete--");
    }
});
Observable作爲一個被觀察者,並綁定了被觀察者的一個觸發行爲時間,比如小偷是Observable,警察是Observer,,警察不能無緣無端的抓小偷吧,必須要有證據才能去抓,這個證據的
觸發方法就是這裏的ObservableOnSubscribe接口的subscribe()方法,很好理解.
subscribe()方法中有回調參數ObservableEmitter<String> e,這個對象正是下面觀察者中的方法onNext,onError,Oncomplete的操作對象,調用e.onNext(),e.complete()即可觸發這些
行爲,在網路請求數據的時候很好的操作這些網絡數據.很靈活.
注意Observer中的onSubscribe方法下的dispoable 對象可以攔截接下來的操作,調用d.dispose()即可;
最後是訂閱這個觀察者,observable.subscribe(觀察者),這次流程就已經完成.

案例打印出來的正是:

1,當訂閱事件後首先執行的是onSubscribe--
2,subscribe
4,onNext--
5,onComplete--

看着順序是不是覺的有點疑惑?

按我們思維肯定是:

2,subscribe
4,onNext--
5,onComplete--

這個需要大夥們去探查Rxjava源碼了,反正這不重要,知道流程就可以起飛了.


數據轉換


Rxjava潮熱,少不了,這一點.看下例子:


Observable<String> observable=Observable.create(new ObservableOnSubscribe<String>() {
    @Override
    public void subscribe(ObservableEmitter<String> e) throws Exception {
        System.out.println("2,subscribe");
        e.onNext("observable");
        e.onComplete();
    }
}).map(new Function<String, String>() {
    @Override
    public String apply(String s) throws Exception {
        System.out.println("3,數據處理apply--");
        return s;
    }
});

observable.subscribe(new Observer<String>() {
    @Override
    public void onSubscribe(Disposable d)
    {d.dispose();
        System.out.println("1,當訂閱事件後首先執行的是onSubscribe--");

    }

    @Override
    public void onNext(String value) {
        System.out.println("4,onNext--");
    }

    @Override
    public void onError(Throwable e) {
        System.out.println("onError--");
    }

    @Override
    public void onComplete() {
        System.out.println("5,onComplete--");
    }
});
map操作符的使用,以網絡請求數據爲例,在subscribe()方法中獲取數據後,我們想對數據進行一個轉換,這時候使用map是最好的了,

看下打印結果就明白:

1,當訂閱事件後首先執行的是onSubscribe--
2,subscribe
3,數據處理apply--
4,onNext--
5,onComplete--


Rxjava還有很多這種操作符:

Combining Obsercables(Observable的組合操作符)

操作符         功能
combineLatest 兩個Observable產生的結果合併成新Observable,任意Observable產生的結果和另一個Observable最後產生的結果按規則合併
join like combineLatest 能控制每個Observable產生結果的生命週期,在每個結果的生命週期內,與另一個Observable產生的結果按規則合併
groupJoin like join 暫不知其他區別
==merge== ==按照兩個Observable的提交結果的時間順序,對Observable合併。時間按某Observable完成的最小時間==
mergeDelayError 合併的某一個Observable中出現錯誤,把錯誤放到所有結果都合併完成之後,訂閱者回調執行onError。而merge會馬上停止合併
startWith 源Observable提交結果之前,插入指定數據
switchOnNext 把一組Observable轉換成Observable。這組Observable中取最後一個Observable提交的結果給訂閱者。
==zip== ==把兩個Observable提交的結果按照順序進行合併。==

Error Handing Operators(Observable的錯誤處理操作符)

操作符    功能
onErrorReturn    在Observable 發生錯誤或異常(即將回調onError)時,攔截錯誤並執行指定的邏輯,返回一個跟源Observable相同類型的結果,最後回調訂閱者的onComplete方法
onErrorResumeNext like onErrorReturn 不同的是返回一個Observable 例:return Observable.just(5,2,0);
onExceptionResumeNext like onErrorResumeNext 不同的是只有在exception的時候觸發
==retry== ==當Observable發生錯誤或異常,重新執行Observable的邏輯,如果經過n次重新執行後仍然出現錯誤或異常,則最後回調onError方法,若無錯誤或異常則按正常流程執行 例:observable.retry(2).subscribe();==
retryWhen like retry 不同在於retryWhen是在源Observable出現錯誤或異常時,通過回調第二個Observable來判斷是否重新嘗試執行源Observable的邏輯;若第二個Observable沒錯誤或異常,則會重新嘗試執行源Observable的邏輯,否則就會直接回調執行訂閱者的onError();

其他常用

操作符 功能
map 對源Observable數據的加工處理,返回其他類型 例:return 520+”string data”;
flatMap like map 不同的是返回一個Observable 擴展:使用了merge操作符 例:return Observable.from(…);
concatMap like concatMap 不同的是concatMap操作遵循元素的順序 擴展:使用了concat操作符
compose 唯一一個能從流中獲取原生Observable的方法,因此,影響整個流的操作符(subscribeOn()和observeOn())需要用compose()。當你創建一個Observable流並且內聯了一堆操作符以後,compose()會立即執行,所以compose轉換的是整個流
compose與flagMap的區別 flatMap()一定是低效率的,因爲他每次調用onNext()之後都需要創建一個新的Observable,compose()是操作在整個流上的
concat 按順序依次連接兩個或更多的 Observable
first 從序列中取第一個先完成的項
takeFirst like first 區別是first()如果沒有釋放有效的數據源,那麼會throw NoSuchElementException;而takeFirst會complete沒有 exception




線程控制


在Rxjava中可以控制觀察者和被觀察者的線程執行,subscribeOn()和 observeOn(),所以可以利用在被觀察者中subscribe()在子線程去獲取網絡數據,再切換觀察者在主線程更新UI,是不是很有邏輯性.

介紹線程切換的主要參數:

Schedulers.immediate(): 直接在當前線程運行,相當於不指定線程。這是默認的 Scheduler。 

Schedulers.newThread(): 總是啓用新線程,並在新線程執行操作。

Schedulers.io(): I/O 操作(讀寫文件、讀寫數據庫、網絡信息交互等)所使用的 Scheduler。行爲模式和 new Thread() 差不多,區別在於 io() 的內部實現是是用一個無數量上限的線程池,可以重用空閒的線程,因此多數情況下 io() 比new Thread()更有效率。不要把計算工作放在 io() 中,可以避免創建不必要的線程。 

 Schedulers.computation(): 計算所使用的 Scheduler。這個計算指的是 CPU 密集型計算,即不會被 I/O 等操作限制性能的操作,例如圖形的計算。這個 Scheduler 使用的固定的線程池,大小爲 CPU 核數。不要把 I/O 操作放在computation()中,否則 I/O 操作的等待時間會浪費 CPU。 

AndroidSchedulers.mainThread():主線程



今天就介紹到這裏......

下一章講解與Retrofit的結合

貼上幾個有助於理解的博客:

http://www.tuicool.com/articles/Jr2AJvN



發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章