2. 程式人生 > >RxJava學習筆記---簡單使用

RxJava學習筆記---簡單使用

阿新 • • 發佈：2019-01-10

如果覺得一篇文章寫得好，不要放到收藏夾裡面，馬上把它看完，如果兩天內還沒開始看，那就可以刪掉了
如果覺得一樣技術很好，那就馬上去學，不要拖延，不要找藉口。如果你一週內還沒開始行動，還不如坦蕩點放棄
恰如克林克茲所說：
與其感嘆路難行，不如馬上出發
去年就在看RxJava，每次看一點點，遇到障礙，感嘆要理解的東西太麻煩就放棄了。今年決心要搞定它，學習的過程註定孤獨單調，恰好現在開始寫Blog，就順便記錄下學習筆記，以此自勉。在後面的2-4周計劃：

  1. 明白RxJava的基本用法，API中常用類、函式、變換
  2. 學習使用RxJava寫的開源App，提升熟練度
  3. 研究RxJava內部實現，研究他為什麼要如此設計API，如此好用
  4. 用RxJava寫一個App，開源

RxJava是什麼

Rx是什麼

Rx全稱Reactive Extensions，譯為響應式拓展。

微軟最先提出這個概念，借用MSDN上的定義：Reactive Extensions（Rx）是一個類庫，它集成了非同步、基於可觀察（observable）序列的事件驅動程式設計和LINQ-style的查詢操作，使用Rx，開發人員

  • 可以用observable物件描述非同步資料流
  • 使用LINQ操作符非同步查詢資料
  • 使用Schedulers控制非同步過程中的併發
    簡而言之
Rx = Observables + LINQ + Schedulers

Rx已經滲透到各個語言中，於是有了：
RxJava、RxJS、Rx.NET、UniRx、RxScala、RxCpp、 RxSwift、RxPHP、Ruby: Rx.rb、Python: RxPY等等
基於frameworks上還有
RxNetty、RxAndroid、RxCocoa

RxJava的定義

RxJava是Rx在Java語言上的擴充套件。
RxJava
– Reactive Extensions for the JVM – a library for composing asynchronous and event-based programs using observable sequences for the Java VM.


譯為：一個在 Java VM 上使用可觀測的序列來組成非同步的、基於事件的程式的庫

RxJava怎麼用

在build.gradle—Module檔案中匯入

    compile 'io.reactivex:rxandroid:1.2.1'
    compile 'io.reactivex:rxjava:1.1.6'

RxJava觀察者模式

RxJava觀察者有4個基本概念組成:

  1. Observer 觀察者
  2. Observable 被觀察者
  3. subscribe() 訂閱
  4. 事件

建立Observer

Observer譯為觀察者，直接建立實現

        Observer<String> observer = new Observer<String>() {
            @Override
            public void onCompleted() {
                Log.d(TAG, "onCompleted: ");
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError: " + e.toString());
            }

            @Override
            public void onNext(String s) {
                Log.d(TAG, "onNext: " + s);
            }
        };

對比常用的給控制元件註冊一個監聽事件

        class MyListener extends View.OnClickListener {
            @Override
            public void onClick(View v) {
                Log.d(TAG, "onClick: ");
            }
        }

這裡的RxJava的onNext()方法就對應MyListener的onClick()方法，不過比起後者Observer還多了onCompleted()和onError()

  1. onNext()事件響應
  2. onCompleted()事件佇列結束。不再有新的onNext()發出時，需要觸發其作為結束。
  3. onError() 事件佇列異常。事件佇列處理中若出現異常，onError觸發，佇列終止。
    一個事件佇列中，Error和Completed有且只有一個，並且是事件佇列的最後一個。

建立Subscriber

 Subscriber<String> subscriber = new Subscriber<String>() {
            @Override
            public void onCompleted() {
                Log.d(TAG, "onCompleted: ");
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError: " + e.toString());
            }

            @Override
            public void onNext(String s) {
                Log.d(TAG, "onNext: " + s);
            }
        };

基本使用的話，Subscriber和Observer使用完全一致，實際上在RxJava的subscribe過程中，Observer也常常轉換為Subscriber再使用。但是Subscriber是Oberver的功能升級
檢視其實現程式碼

public abstract class Subscriber<T> implements Observer<T>, Subscription {
    ....
}
  1. 我們知道，Subscriber是一個抽象類，所以我們剛才實現的時候需要實現onCompleted、onError、onNext三個方法
  2. 實現Observer<T>介面
  3. 實現Subscription介面
    Observer<T>介面的實現表明Observer能實現的東西他都可以實現
public interface Observer<T> {
    void onCompleted();
    void onError(Throwable e);
    void onNext(T t);
}

那麼Subscription介面實現呢

public interface Subscription {
    void unsubscribe();
    boolean isUnsubscribed();
}

顧名思義，unsubscribe()表示反註冊；isUnsubscribed()表示是否已經註冊，反註冊和是否已經註冊出現了，哪註冊呢，在這裡

    private final SubscriptionList subscriptions;

    public final void add(Subscription s) {
        subscriptions.add(s);
    }

    @Override
    public final void unsubscribe() {
        subscriptions.unsubscribe();
    }

        @Override
    public final boolean isUnsubscribed() {
        return subscriptions.isUnsubscribed();
    }

add()就是註冊。通過SubscriptionList subscriptions方法轉發實現，我們看看SubscriptionList是什麼

public final class SubscriptionList implements Subscription {

    private LinkedList<Subscription> subscriptions;
    private volatile boolean unsubscribed;

    public SubscriptionList(Subscription s) {
        this.subscriptions = new LinkedList<Subscription>();
        this.subscriptions.add(s);
    }

    @Override
    public boolean isUnsubscribed() {
        return unsubscribed;
    }

    public void add(final Subscription s) {
        if (s.isUnsubscribed()) {
            return;
        }
        if (!unsubscribed) {
            synchronized (this) {
                if (!unsubscribed) {
                    LinkedList<Subscription> subs = subscriptions;
                    if (subs == null) {
                        subs = new LinkedList<Subscription>();
                        subscriptions = subs;
                    }
                    subs.add(s);
                    return;
                }
            }
        }
        s.unsubscribe();
    }


    @Override
    public void unsubscribe() {
        if (!unsubscribed) {
            List<Subscription> list;
            synchronized (this) {
                if (unsubscribed) {
                    return;
                }
                unsubscribed = true;
                list = subscriptions;
                subscriptions = null;
            }
            unsubscribeFromAll(list);
        }
    }

    private static void unsubscribeFromAll(Collection<Subscription> subscriptions) {
        if (subscriptions == null) {
            return;
        }
        List<Throwable> es = null;
        for (Subscription s : subscriptions) {
            try {
                s.unsubscribe();
            } catch (Throwable e) {
                if (es == null) {
                    es = new ArrayList<Throwable>();
                }
                es.add(e);
            }
        }
        Exceptions.throwIfAny(es);
    }

看到開始定義的

    private LinkedList<Subscription> subscriptions;
    private volatile boolean unsubscribed;

大概就能猜出來，就是通過連結串列來操作的，具體不再深究。回到主題比起Observer來說Subsriber大概有以下幾個優點

  1. 可以使用unsubscribe()取消訂閱。有什麼好處呢？其實和我們使用廣播的時候，註冊和反註冊是一樣的道理，防止記憶體洩漏。
  2. 可以通過isUnsubscribed()獲取當前事件是否註冊，封裝好的方法可以更容易去判斷當前的事件註冊與否的狀態。
  3. onStart()可以在Subscriber剛開始的時候做一些準備工作。我們看到他是一個空實現
    public void onStart() {
        // do nothing by default
    }

就如同在使用Volley或者okhttp的時候也有這種同名方法，做一些初始化操作在請求網路最開始的部分。

建立Observable

Observable.create

  Observable observable = Observable.create(new Observable.OnSubscribe() {
        @Override
        public void call(Object o) {
            subscriber.onNext("1");
            subscriber.onNext("2");
            subscriber.onNext("3");
            subscriber.onCompleted();
        }
    });

儲存一個OnSubscribe物件作為計劃表，一旦Observable被訂閱，call()方法就會被呼叫，然後按照對onNext()和onCompleted()設定的順序依次執行。

Observable.just

上面的例子可以等價於

    Observable observableJust = Observable.just("1", "2", "3");

just—將引數依次發出去

Observable.from

也等價於這種寫法

    String[] tests = {"1", "2", "3"};
    Observable observableFrom = Observable.from(tests);

from—顧名思義從什麼地方來

執行

使用

        observable.subscribe(subscriber);
        observable.subscribe(observer);

事件鏈就可以跑起來了。
這裡subscribe()方法通過下面的方法轉發

static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T> observable) {
        //...省略部分程式碼
        //執行onStart初始方法
        subscriber.onStart();

        //執行Subscriber預設的call()方法
        hook.onSubscribeStart(observable, observable.onSubscribe).call(subscriber);

        //返回傳入的subscriber
        return hook.onSubscribeReturn(subscriber);
    }

列印陣列

把陣列內的值依次打印出來

    private static final Integer[] INT_ARRAYS = {1, 2, 3, 4, 5};

    Observable.from(INT_ARRAYS).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                Log.d(TAG, "call: " + integer);
            }
        });

顯示圖片

把mipmap檔案裡的圖片顯示到介面

  private ImageView ivShow;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ivShow = (ImageView) findViewById(R.id.ivShow);
        Observable.create(new Observable.OnSubscribe<Drawable>() {
            @Override
            public void call(Subscriber<? super Drawable> subscriber) {
                Drawable drawable = getTheme().getDrawable(R.mipmap.bg_splash);
                subscriber.onNext(drawable);
                subscriber.onCompleted();
            }
        }).subscribe(new Observer<Drawable>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {
                Toast.makeText(MainActivity.this, e.toString(), Toast.LENGTH_SHORT).show();
            }

            @Override
            public void onNext(Drawable drawable) {
                ivShow.setImageDrawable(drawable);
            }
        });
    }

但是上面的實現沒有任何意義，因為在同一個執行緒裡面使用還不如直接呼叫。RxJava最大的特性是前臺回撥，後臺處理，是伴隨著多執行緒應運而生的。

Scheduler

        //直接執行在當前執行緒
        Schedulers.immediate();

        //開啟一個新執行緒執行任務

        //內部有一個沒有上限的執行緒池，可以重用空閒執行緒
        //相當於    ExecutorService executorService = Executors.newCachedThreadPool();
        Schedulers.io();

        //有一個固定執行緒池，大小為CPU核心數+1
        //等價於  Executors.newFixedThreadPool(nCore+1)
        Schedulers.computation();

剛才的例子：
被建立的陣列值在IO執行緒發出，在主執行緒處理列印

        Observable.from(INT_ARRAYS)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.d(TAG, "call: " + integer);
                    }
                });

在IO執行緒載入圖片，在主執行緒顯示圖片

        Observable
                .create(new Observable.OnSubscribe<Drawable>() {
                    @Override
                    public void call(Subscriber<? super Drawable> subscriber) {
                        Drawable drawable = getTheme().getDrawable(R.mipmap.bg_splash);
                        subscriber.onNext(drawable);
                        subscriber.onCompleted();
                    }
                })
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<Drawable>() {
                    @Override
                    public void onCompleted() {

                    }

                    @Override
                    public void onError(Throwable e) {
                        Toast.makeText(MainActivity.this, e.toString(), Toast.LENGTH_SHORT).show();
                    }

                    @Override
                    public void onNext(Drawable drawable) {
                        ivShow.setImageDrawable(drawable);
                    }
                });

相關推薦

RxJava學習筆記---簡單使用

如果覺得一篇文章寫得好，不要放到收藏夾裡面，馬上把它看完，如果兩天內還沒開始看，那就可以刪掉了 如果覺得一樣技術很好，那就馬上去學，不要拖延，不要找藉口。如果你一週內還沒開始行動，還不如坦蕩點放棄 恰如克林克茲所說： 與其感嘆路難行，不如馬上出發 去年就

## vue學習筆記--簡單父子組件--

his scrip 變量 event cli 通訊 按鈕 itl 事件 ## vue學習筆記 ### 組件之間的通訊1. 父組件到子組件```js //father <div> <son msg="父組件的信息寫在這">&l

PHP學習筆記-簡單的面向過程寫的驗證碼

php<?php /** * Created by PhpStorm. * User: Administrator * Date: 2017\10\10 0010 * Time: 19:44 */ //生成隨機驗證碼 $strNumber = join(‘‘,range(0,9)); $s

[python 學習筆記] 簡單刷投票功能

ets con ext erer wifi turn 發送 use gen 最近好久沒寫了，其實有道雲裏積累了好多,但是沒時間整理。 實在是太多事情要做了 好多投票都是不需要登錄的，這種刷起來很簡單。 原理就是 X-Forwarded-For 。廢話不多說上代碼 impor

【轉】Verilog學習筆記簡單功能實現（八）...............異步FIFO

另一個 gif 多個 可靠 基本原理 drs bar next 不同 基本原理： 1.讀寫指針的工作原理 　　寫指針：總是指向下一個將要被寫入的單元，復位時，指向第1個單元(編號為0)。 　　讀指針：總是指向當前要被讀出的數據，復位時，指向第1個單元(編號為0)

RxJava學習 筆記

RxJava學習筆記 RxJava的好處 RxJava 的觀察者模式 執行緒控制器 Scheduler

《全棧開發之道》MEAN學習筆記-簡單的商品管理功能

本文介紹了利用MEAN技術棧(MongoDB,Express,Angular,Node.js)構建一個簡單的商品管理功能 所需環境：Node.js、MongoDB  、（git） 先建立一個基於EJS的Express工程 express --view=ejs my

仙人掌&圓方樹學習筆記+簡單應用

仙人掌&圓方樹學習筆記 前言 一直覺得仙人掌和圓方樹是非常高深的演算法。 直到連續隨機跳題跳到兩道。我受不了啦！！！ 於是點進了一個連結。（傳銷現場有木有啊！） 推薦連結 ：戳這裡 然後發現並沒有想象中那麼難。 而且，，， 很好玩。 日常賽前學演算法（大

RxJava 學習筆記（九） --- Error Handling 錯誤處理操作

1. onErrorReturn —> 指示Observable在遇到錯誤時發射一個特定的資料 onErrorReturn方法返回一個映象原有Observable行為的新Obse

Rxjava學習筆記(一)

RxJava 2.0 要在Android中使用RxJava2, 先新增Gradle配置: compile ‘io.reactivex.rxjava2:rxjava:2.0.1’ compile ‘io.reactivex.rxjava2:rxa

java設計模式學習筆記--簡單工廠模式

1. 什麼是簡單工廠模式 簡單工廠模式是屬於建立型模式，又叫做靜態工廠方法（Static Factory Method）模式。簡單工廠模式是由一個工廠物件決定創建出哪一種產品類的例項。但是嚴格來說，簡單工廠模式不是設計模式，它更像是一種程式設計習慣。 2.

RxJava學習筆記_原理理解

一、三大程式設計方式 看到有大神部落格精妙總結（https://www.jianshu.com/p/15b2f3d7141a），以大象裝冰箱為例，借鑑過來。 1、函數語言程式設計（面向過程）     第一步：構建一個函式，接收大象和冰箱兩個引數  

RxJava學習筆記之Subscriber

Subscriber是訂閱者需要實現的介面。 方法： public void onSubscribe(Subscription s); Publisher.subscriber（Subscriber）之後呼叫。 public void onNext(T t); 媒體發出

rxJava學習筆記之observeOn

一段最簡單的程式碼 longOpeSubscription = Observable.create(new Observable.OnSubscribe<String>() { @Override

RxJava學習筆記（一）

*** 學習參考部落格： *** 1、在gradle中新增，載入RxJava框架： compile 'io.reactivex:rxjava:1.1.2' 2、RxJava中主要涉及兩個類： 被觀察者類（可觀察）：Observable<T> 訂閱者（事

批處理命令學習筆記——簡單的批處理應用例項

(1) 利用 FOR 迴圈掃描 IP 地址 下面的命令使用了4個FOR巢狀，用法為：“C:\>TEST.BAT <網路地址>”。 for /l %%a in (0,1,255) do for /l %%b in (0,1,255) do (     for

RxJava 學習筆記

“a library for composing asynchronous and event-based programs using observable sequences for the Java VM”（一個在 Java VM 上使用可觀測的序列組成非同步的、基於事件的程式的庫） RxJava 的

JDBC學習筆記——簡單UerDao

his 實例 bsp 插入數據 統一 jdbcutils div aoe rep 　　JDBC(Java DataBase Connectivity,java數據庫連接)是一種用於執行SQL語句的Java API，可以為多種關系數據庫提供統一訪問，它由一組用Java語言編寫

FullCalendar 學習筆記——簡單的節假日設定

FullCalendar作為一款功能強大的日曆外掛，用途十分廣泛。今天我們用它來實現一個簡單的節假日設定功能，程式碼非常簡潔，有助於理解外掛的呼叫方式。本文程式碼需用到SpringMVC和Mysql。 1、在官網下載fullCalendar.js（LZ的js和

Android學習筆記——簡單實現照相、錄音和錄影功能

       Android菜鳥第一次寫原創部落格，大神請輕噴，共同進步。     最近剛接觸到如何實現一個簡單的照相機功能，然後又將錄音和錄影功能加了進去。ps：錄影功能相對複雜，自己實現起來比較困難，我就直接在程式裡呼叫系統的錄影功能了。以後在慢慢學習：）好，言歸正傳。