RxJava學習筆記1

RxJava：Reactive ->響應式編程框架

整體採用觀察者設計模式<被觀察着Observable ,觀察者(訂閱者) Observer (Subscriber) >

作用總結爲：異步操作 觀察者模式本身的目的就是『後臺處理，前臺回調』的異步機制

優勢:簡潔<這裏說的是使邏輯簡單明瞭,並不是單純的代碼數量> 所有的複雜的邏輯都可以簡化成一條鏈上的操作 這個稍後用代碼來實際驗證一下

概念介紹: 既然是觀察者模式,RxJava也包含了下列四個對象:

• Observable (可觀察者，即被觀察者)、
• Observer (觀察者)、
• subscribe (訂閱)、

• 事件。
  Observable 和 Observer 通過 subscribe() 方法實現訂閱關係，
  從而 Observable 可以在需要的時候發出事件來通知 Observer。

  就和設置事件監聽器的感覺一樣,有木有,這下感覺有木有清晰點,能幹嘛知道了吧
  不知道,這麼說吧,
  你室友跟你說，喫飯的時候叫我一起,然後你到了喫飯的時候，你就會叫他，然後一起去喫飯
  Observable ——你
  Observer——你室友
  subscribe——跟你說好的
  事件 ——喫飯
  

//注意這是我去掉了許多不是重點的重要代碼 什麼重寫標識,我就不留着了佔地方 我們看重點
Observer<String> observer = new Observer<String>() { //監聽器麼,重寫了三個方法,可以在這三個方法裏做自己想做的事情，注意,<T> 這裏面的類型就是 傳遞給觀察者的數據類型,
    public void onNext(String s) {}//這裏的數據也是相應的數據類型
    public void onCompleted() {} //完成了就完成了唄，沒必要把數據傳給你吧
    public void onError(Throwable e) {} //錯誤了，傳回來了一個錯誤信息體，可以打印出來讓我們知道怎麼了
};

注意,請看我的前面的觀察者後面有一個訂閱者Subscriber，可以說和觀察者一樣的哦，用起來也差不多，也是實現了Observer 的一個抽象類: 既然名字不一樣 我們直接看區別吧
區別:
1.多出來了一個回調方法(這是一個可選方法，默認情況下它的實現爲空)onStart():

會在 subscribe 剛開始，而事件還未發送之前被調用，可以用於做一些準備工作，例如數據的清零或重置。

注意，如果對準備工作的線程有要求（例如彈出一個顯示進度的對話框，這必須在主線程執行）， onStart() 就不適用了，因爲它總是在 subscribe 所發生的線程被調用，而不能指定線程。想指定工作線程後面說，現在不說多了，以免亂了

2.多出來一個可以調用的方法 unsubscribe()
Subscriber 所實現的另一個接口 Subscription 的方法，用於取消訂閱，取消訂閱之後就不會再接收到相應事件。

調用前，可以使用 isUnsubscribed() 先判斷一下。 unsubscribe() 這個方法很重要，因爲在 subscribe() 之後， Observable 會持有 Subscriber 的引用，這個引用如果不能及時被釋放，將有內存泄露的風險要在不再使用的時候儘快在合適的地方（例如 onPause() onStop() 等方法中）調用 unsubscribe() 來解除引用關係，以避免內存泄露的發生。

2.創建 Observable

Observable 即被觀察的對象，它決定什麼時候觸發事件以及觸發怎樣的事件。

RxJava 使用 create() 方法來創建一個 Observable ，併爲它定義事件觸發規則：

Observable observable = Observable.create(new Observable.OnSubscribe<String>() {
    public void call(Subscriber<? super String> subscriber) { 
        subscriber.onNext("Aloha");
        subscriber.onCompleted();
    }
});

傳入一個 OnSubscribe 對象作爲參數。OnSubscribe 會被存儲在返回的 Observable 對象中，它的相當於一個計劃表

當 Observable 被訂閱的時候，OnSubscribe 的 call() 方法會自動被調用，事件序列就會依照設定順序依次觸發（對於上面的代碼，就是觀察者Subscriber 將會被調用1次 onNext() 和1次 onCompleted()）。

被觀察者調用了觀察者的回調方法，就實現了由被觀察者向觀察者的事件傳遞，即觀察者模式。

這是個比較完整的創建模式,對於創建對觀察對象，還有幾個常用的創建方法

just(T…): 將傳入的參數依次發送出來。

Observable observable = Observable.just("Hello", "Hi", "Aloha");
// 將會依次調用：
// onNext("Hello");
// onNext("Hi");
// onNext("Aloha");
// onCompleted();

from(T[])將傳入的數組 拆分成具體對象後，依次發送出來
from(Iterable

String[] words = {"Hello", "Hi", "Aloha"};
Observable observable = Observable.from(words);
// 將會依次調用：
// onNext("Hello");
// onNext("Hi");
// onNext("Aloha");
// onCompleted();

3.Subscribe (訂閱)

創建了 Observable 和 Observer 之後，再用 subscribe() 方法將它們聯結起來，整條鏈子就可以工作了。代碼形式很簡單：

observable.subscribe(observer);
// 或者：
observable.subscribe(subscriber);

分析subcribe()的方法內部 ,核心代碼部分

public Subscription subscribe(Subscriber subscriber) {
    subscriber.onStart(); //先調用 start方法 
    onSubscribe.call(subscriber);//再將訂閱者傳入call方法 實現進一步回調 
     //Observable 並不是在創建的時候就立即開始發送事件，而是在它調用subscribe() 方法執行的時候。
    return subscriber;//返回觀察者
}

//訂閱者的不完整實現
  Action0, 1, 2, 3, 4 >>> > 參數的個數
        無參數 -> onComplete()
        一個參數（Throwable e）->onError
        一個參數(T t)->onNext()
        Action1<String> onNext = new Action1<String>() {
            public void call(String s) {
            }
        }; //next
        Action1<Throwable> onError = new Action1<Throwable>() {
            public void call(Throwable throwable) {
            }
        };
        Action0 onCompleted = new Action0() {
            public void call() {
            }
        };

// 自動創建 Subscriber

//使用 onNext 來定義 onNext()
observable.subscribe(onNext);

// 使用 onNext 和 onError 來定義 onNext() 和 onError()
observable.subscribe(onNext, onError);

// 使用 onNext、 onError 和 onCompleted 來定義 onNext()、 onError() 和 onCompleted()
observable.subscribe(onNext, onError, onCompleted);

“`

在 RxJava 的默認規則中，事件的發出和消費都是在同一個線程的。
只用上面的方法，實現的只是一個同步的觀察者模式。
觀察者模式本身的目的就是
“後臺處理，前臺回調”的異步機制，
要實現異步(異步纔是RxJava的重點)，
需要使用RxJava中的重頭戲 >>>>>>>>>>>>”Scheduler” 來實現線程調度
下一篇吧
——————————————————————————————