Android官方響應式框架Agera詳解：一、相關概念和基本使用

Android

前言

在學習 Agera 之前沒有接觸過響應式編程和 RxJava ，所以當時學起來非常的費勁，也踩了很多坑。寫這篇博客的目的就是把自己學習到的成果分享出來，希望能夠幫助那些需要的人

后面的文章已經更新啦~
Android官方響應式框架Agera詳解：二、Repository的創建和操作符
Android官方響應式框架Agera詳解：三、Repository的更新規則及Agera+Retrofit+Okhttp實戰

目錄

一、Agera 及相關概念簡介
二、Agera 使用示例
三、Agera 相關類和基本使用
四、Repository 的分類和創建使用
五、總結
六、相關代碼
七、預告

一、Agera 及相關概念簡介

Agera

Agera的github地址

Agera is a set of classes and interfaces to help write functional, asynchronous, and reactive applications for Android.Requires Android SDK version 9 or higher

簡單翻譯一下，Agera 是一組類和接口，幫助安卓開發者實現功能性的、異步的和響應式的應用。要求Android 的 SDK 版本在9以上

Agera (瑞典文的意思是"采取行動")是一個超輕量級的 Android 庫，幫助 Android 應用中有生命周期的組件(比如:Activities)或者組件中的對象(比如:Views)預準備數據。 通過加入函數式響應式編程，Agera可以在 什么時機, 什么線程 和 什么數據 層面上更清晰的分離數據處理流程，并且使用一個接近自然語言的單個表達式就能編寫一個復雜的異步流

觀察者模式

Agera 使用著名的 觀察者模式 作為響應式編程的驅動機制。 被觀察者(observable)實現 Observable 接口， 并向所有注冊的觀察者們(observers)廣播事件。 觀察者(observer)實現 Updatable 接口, 可以注冊和注銷到 Observable 中，接受通知事件觸發更新操作，故此命名為 Updatable

Push event, pull data

Agera 使用 push event, pull data 模型(推送事件,拉取數據)。
push event：被觀察者只做事件通知，不攜帶任何數據;
pull data：觀察者根據自己需要從數據倉庫(Repository.get())拉取數據

注冊/注銷 觀察者

Updatable 的注冊和注銷必須配對使用。不能重復注冊 Updatable，不能注銷沒有注冊過的 Updatable，也不能重復注銷 Updatable，等其他非法操作

public class Test extends Activity {
    //被觀察者
    Observable observable = new Observable() {
        @Override
        public void addUpdatable(@NonNull Updatable updatable) {
        }
        @Override
        public void removeUpdatable(@NonNull Updatable updatable) {
        }
    };
    //觀察者
    Updatable updatable = new Updatable() {
        @Override
        public void update() {
        }
    };

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
    }

    @Override
    protected void onResume() {
        super.onResume();
        //注冊觀察者
        observable.addUpdatable(updatable);
    }

    @Override
    protected void onPause() {
        super.onPause();
        //注銷觀察者
        observable.removeUpdatable(updatable);
    }
}

Activation lifecycle

被觀察者(Observable)的有兩種狀態：

  1. active狀態(活動狀態)：有觀察者 (至少注冊一個了Updatable)
  2. inactive狀態(非活動狀態)：沒有觀察者 (沒有注冊的Updatable)

也就是, 注冊 Updatable 讓 Observable 從非活動狀態激活為活動狀態，當 Updatable 全部注銷了，Observable 從活動狀態變為非活動狀態

二、 Agera 使用示例

為了讓小伙伴們對 Agera 有一個最初的印象，這里先給出一個 Agera 的使用示例

假設一下，有一個業務場景：

  1. 有一個按鈕，當我們點擊的時候在子線程進行網絡請求，下載一張圖片
  2. 切換到另一個子線程去壓縮圖片
  3. 回到主線程顯示出圖片
    //網絡請求框架
    OkHttpClient client = new OkHttpClient.Builder()
            .addInterceptor(new HttpLoggingInterceptor().setLevel(HttpLoggingInterceptor.Level.BODY))
            .build();

    Repository<Result<Bitmap>> repository = Repositories.repositoryWithInitialValue(Result.<Bitmap>absent())
            .observe()
            .onUpdatesPerLoop()
            .goTo(NETWORK_EXECUTOR)  //切換到子線程進行網絡請求
            .attemptGetFrom(() -> {
                runOnUiThread(() -> tvState.setText("正在子線程進行圖片下載..."));
                //網絡請求部分
                Request request = new Request.Builder()
                        .url(IMAGE_URL)
                        .get()
                        .build();
                try {
                    Response response = client.newCall(request).execute();
                    if (response.isSuccessful()) {
                        //為了更清楚的觀察狀態，此處休眠一秒
                        Thread.sleep(1000);
                        return Result.present(response.body().byteStream());
                    } else {
                        //網絡請求失敗時的處理
                        return Result.failure(new Throwable("下載圖片失敗！" + response.code() + response.message()));
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                    //異常時的處理
                    return Result.failure(new Throwable("下載圖片異常！" + e.getMessage()));
                }
            })
            .orEnd(Result::failure)
            .goTo(COMPRESS_EXECUTOR) //切換到壓縮圖片的線程
            .thenTransform(input -> {
                runOnUiThread(() -> tvState.setText("正在子線程進行圖片壓縮..."));
                //壓縮圖片的部分
                try {
                    BitmapFactory.Options options = new BitmapFactory.Options();
                    options.inSampleSize = 2;
                    Bitmap bitmap = BitmapFactory.decodeStream(input, new Rect(0, 0, 0, 0), options);
                    Thread.sleep(1500);
                    return Result.present(bitmap);
                } catch (Exception e) {
                    e.printStackTrace();
                    return Result.failure(new Throwable("壓縮圖片異常！" + e.getMessage()));
                }
            })
            .compile();

    Updatable updatable = new Updatable() {
        @Override
        public void update() {
            repository.get()
                    //上面所有的流程都正確執行
                    .ifSucceededSendTo(value -> {  
                        tvState.setText("加載圖片完成");
                        ivImage.setImageBitmap(value);
                    })
                    //上面的流程發生錯誤
                    .ifFailedSendTo(value -> tvState.setText(value.getMessage()));
        }
    };

效果圖如下：


下載圖片.gif

如果看不太懂沒關系，后面我們會慢慢學到。

雖然你可能沒有看太懂，但是通過代碼你也可以感受到 Agera 的強大，整體非常簡潔，切換線程非常方便，只需一個 goto() 方法。

其實，在網絡請求那一部分我們還可以用更簡潔的代碼去完成，需要使用 Agera + Retrofit + Okhttp 三個框架來共同完成，這個我們后面也會講到

好了，對 Agera 有了初步的印象后，讓我們一起開始學習吧

三、 Agera相關類和基本使用

在 Agera 中，有幾個比較重要的類和接口，我們以它們為切入點，一步一步地學習如果使用 Agera

最開始的時候介紹了，Agera 是基于觀察者模式的，首先我們看一下觀察者、被觀察者在 Agera 中是如何表現的

1、 Updatable

翻譯為 ：觀察者
用途：接收事件通知，更新數據
說明：觀察者模式中的 Observer，在 Agera 中使用 Updatable

我們看一下它的代碼，非常簡單，它是一個接口，包含一個 update() 方法。

public interface Updatable {
  void update();
}

2、 Observable

翻譯為：被觀察者、事件源
用途：作為事件源，通知觀察者更新數據，可以注冊、注銷觀察者。
說明：當事件發生的時候，調用 dispatchUpdate() 通知觀察者。

Observable 也是一個接口，里面包含兩個方法，一個用于添加觀察者(也就是 Updatable )，一個用于移除觀察者( Updatable )

當有事件發生的時候，被觀察者(也就是 Observable ) 會通知所有添加過的觀察者( Updatable )

public interface Observable {
  void addUpdatable(@NonNull Updatable updatable);
  void removeUpdatable(@NonNull Updatable updatable);
}

注意，Updatable 的注冊和注銷必須配對使用

小結

我們先做一個小結

  1. Agera 是基于觀察模式的，Updatable 指代的是觀察者模式中的觀察者，而 Observable 所指代的就是觀察者模式中的被觀察者

  2. Agera 的更新機制是：使用 Updatable 去觀察Observable，Observable 去通知 Updatable 更新

現在我們了解了 Agera 的更新機制，那具體到代碼中是如何使用的呢？

  1. 定義一個 Updateable 和一個 Observable
  2. 使用 Observable 的 addUpdatable() 方法去將Updatable 注冊到 Observable 中
  3. 當某個事件發生時調用 Updatable 的 update() 方法進行更新操作
  4. 當我們不使用的時候，注銷 Updatable

下面我們來看一個具體的例子，按照上面的三個步驟實現。在布局中定義一個 Button 和 TextView，當點擊這個 Button 的時候，更新 TextView 中的文字

public class SimpleActivity extends Activity {

    Button btnTest;
    TextView tvHello;

      // 步驟1 定義一個 Updatable 
    Updatable updatable = new Updatable() {
        @Override
        public void update() {
           //當收到更新事件時，更新TextView中的文字
            tvHello.setText("Hello Agera");

            //步驟4 注銷 Updatable 
             observable.removeUpdatable(updatable);
        }
    };

    //步驟1 定義一個Observable 
    Observable observable = new Observable() {
        @Override
        public void addUpdatable(@NonNull Updatable updatable) {
            //步驟3 當某個 Updatable 被注冊時，通知該 Updatable 更新
            updatable.update();
        }

        @Override
        public void removeUpdatable(@NonNull Updatable updatable) {
        }
    };

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_simple);

        btnTest = findViewById(R.id.btnTest);
        tvHello = findViewById(R.id.tvHello);

        btnTest.setOnClickListener(v -> 
        //步驟2 使用Observable的addUpdatable()方法去將Updatable注冊到Observable中
        observable.addUpdatable(updatable));
    }
}

由于代碼比較簡單，此處就不在給出實現的效果圖了

看到這里，有的小伙伴可能會有疑問了，這么簡單一個功能，我直接在點擊事件那里去更新TextView的提示就好了，何必要費那么大功夫，寫一個什么觀察者、被觀察者去實現？(這不就是 一頓操作猛如虎，一看戰績0-5么。。。orz)

剛開始接觸的時候可能會不太理解 Agera (觀察者模式)的工作機制，這個例子的目的是讓大家更好地理解 Agera 的工作模式

理解了上面的內容，我們繼續往下看：

3、 Supplier

翻譯為：數據提供者
用途：get()新數據

Supplier 是一個帶泛型參數的接口，它有一個 get() 方法，返回一個T類型的值

public interface Supplier<T> {
  @NonNull
  T get();
}

Supplier 該怎么理解呢？簡單來說，它只有一個功能，就是提供一個數據。甚至就可以把它理解為一個變量

它的使用是這樣的：

  //定義一個數據為String類型的Supplier
  Supplier<String> stringSupplier = new   Supplier<String>() {
        @Override
        public String get() {
            //這里提供具體的值
            return "hello";
        }
    };
 
  //get()方法拿到上面提供的具體值
  //輸出 hello
   Log.d("tag", "stringSupplier " + stringSupplier.get()); 


  Supplier<Integer> integerSupplier = new Supplier<Integer>() {
        @Override
        public Integer get() {
            return 666;
        }
    };
    //輸出 666
    Log.d("tag", "integerSupplier " + integerSupplier.get());


  Supplier<JSONObject> jsonObjectSupplier = new Supplier<JSONObject>() {
        @Override
        public JSONObject get() {

            try {
                JSONObject jsonObject = new JSONObject("{\n" +
                        "    \"returnCode\": \"0000\",\n" +
                        "    \"returnMessage\": \"success\"\n" +
                        "}");
                return jsonObject;

            } catch (JSONException e) {
                e.printStackTrace();
            }

            return null;
        }
    };
   //輸出 {"returnCode":"0000","returnMessage":"success"}
    Log.d("tag", "jsonObjectSupplier " + jsonObjectSupplier.get().toString());

看到這，你應該已經明白了它的作用了，非常簡單對吧。你可能還會有疑問，只是用于提供一個值，那我直接提供一個變量值就行了，為啥要巴拉巴拉寫那么大一堆？(難道又是傳說中的一頓操作猛如虎。。。)

我是這么理解的，Supplier 是一個提供數據的接口，它不僅僅是提供了一個數據，關鍵是它代表了一種能力和一種規范，什么能力？能夠提供一個數據的能力！什么規范？當需要獲取數據時數據源必須是 Supplier 的規范！這種能力和規范接下來我們會接觸到

在實際的代碼中，它也沒有像上面那樣復雜，我們會使用lambda表達式還有匿名類將其簡化，比如

//使用lambda表達式簡化
 Supplier<String> stringSupplier = () -> "hello";


//使用lambda表達式和匿名類簡化
Repositories.repositoryWithInitialValue(0)
             .observe()
             .onUpdatesPerLoop()
            //注意，getFrom方法的參數必須是一個Supplier 。這就是上面說到的規范
             .getFrom(() -> "hello agera")
             ...
             ...//后面省略了一頓操作


//如果你是用Kotlin語言的話，還可以簡化成下面這樣
Repositories.repositoryWithInitialValue(0)
            .observe()
            .onUpdatesPerLoop()
            //同樣的參數必須是一個Supplier，此處是用lambda表達式簡化
            .getFrom { "hello Kotlin" }
            ...
            ...//后面省略了一頓操作
    ...

4、 Receiver

翻譯為：數據接收者
用途：accept(T vaule)接收新數據。

public interface Receiver<T> {
  void accept(@NonNull T value);
}

Receiver 是一個數據接收者，它與上面的講的 Supplier 的作用剛好相反。Receiver 也定義了一種能力和規范。能力是接收一個數據。規范是在 Agera中接收數據時，必須使用 Receiver 接口

在實際代碼中是這樣的：

   repository.get()
             .ifSucceededSendTo(new Receiver<Bitmap>() {
                        @Override
                        public void accept(@NonNull Bitmap value) {
                          //value值就是我們接收到的數據
                        }
                    })
             .ifFailedSendTo(new Receiver<Throwable>() {
                        @Override
                        public void accept(@NonNull Throwable value) {

                        }
                    });

上面代碼中的 ifSucceededSendTo 和 ifFailedSendTo 這兩個方法的參數都是一個 Receiver 對象

Supplier 定義了一種能力，提供 一個數據的能力
Receiver 定義了一種能力，接收 一個數據的能力

5、 Repository

翻譯為：Repository、數據倉庫
用途：接收事件源、提供數據源的結合體

上面我們已經知道了 Updatable (觀察者)和 Observable(被觀察者)，兩個主角都已經就位了。那這個 Repository 又是何方神圣？它難道要來搶女一號？

是的，它才是真真正正主角。我們來看一下它的實現：

public interface Repository<T> extends Observable, Supplier<T> {
}

它是一個接口，繼承了 Observable 接口和 Supplier 接口。

Observable 接口代表了是一個被觀察者，Supplier 代表了有提供數據的能力，Repository 同時繼承了這兩個接口說明什么？說明了它是一個 擁有提供數據能力的被觀察者！

Repository 翻譯為 倉庫 (或者數據倉庫)。名字非常形象，既然是倉庫，肯定能從它那里拿到貨物(也就是我們需要的數據)

我們回想一下上面的那個例子，Observable 作為一個被觀察者，它能夠在某個事件發生時通知 Updatable。注意，這里僅僅是通知，并沒有提供任何數據。這也就是為什么會產生 Repository 的原因

Repository 彌補了不能提供數據的缺陷，它是擁有提供數據能力的被觀察者。與 Observable 相比它不僅能在某個事件發生時通知 Updatable，它還能提供一個數據。當 Updatable 收到更新事件的時候，我們就可以從 Repository 中獲取數據，用于后續操作

注：在實際的應用中，我們接觸最多的就是Repository ，它才是真正的主角

6、 MutableRepository

翻譯為：MutableRepository、可改變數據倉庫
用途： 接收事件源、提供數據源的結合體、改變倉庫中的數據

這里怎么突然冒出來個 MutableRepository？ 什么是 MutableRepository ? 它和 Repository 有什么區別？

通過上面的介紹，我們知道，Repository 通過繼承 Supplier 接口，實現了提供數據的能力。

注意哈，這里只是實現了 提供數據的能力。是不是感覺缺少點什么能力？是的，它缺少的就是 改變數據的能力！

在實際的開發中，我們僅僅能從 Repository 得到數據是不夠的，我們還需要的就是能夠需要改變 Repository 中的數據。這也就是 MutableRepository 存在的意義

public interface MutableRepository<T> extends Repository<T>, Receiver<T> {}

MutableRepository 也是一個接口，它繼承了 Repository 接口和 Receiver 接口

繼承 Receiver 接口給 MutableRepository 提供了一項新的能力，接收一個數據。通過 accept(@NonNull T value) 方法接收數據，這樣就是實現了數據倉庫中的數據是可改變的

四、 Repository 的分類和創建使用

Repository 的分類

通過上面的介紹我們了解到，Repository 是擁有提供數據能力的被觀察者。它是一個接口，根據具體能力的不同，它的實現類被分為兩種：

1、簡單的 Repository

簡單的 Repository 又被分為兩種

  1. static repositories ：提供相同的數據源而且不生成通知事件,只有get()方法
  1. mutable repositories : 可提供變化的數據源(accept輸入->get輸出)，數據變化時生成通知事件(依賴方法Object.equals(Object))

2、復雜的repositories

復雜的數據倉庫(Repository)可以響應其他數據倉庫(Repositories)、任意被觀察者(Observables)(也可以是該Repository的事件), 并把從其他數據源獲取的數據經過同步或者異步內部轉換處理后作為數據倉庫(Repository)的產出值。 從響應事件中數據倉庫(Repository)的數據提供者總保持數據最新的，但由于處理的復雜性，在數據倉庫(Repository)不活動時，可以選擇不保持數據為最新的。 任何數據消費者都需要通過注冊觀察者(Updatable)來表示自己需要讀取數據的意圖。 數據倉庫(Repository)進入活動狀態，但數據不用立即更新，消費者看到的數據仍然是舊的，直到數據倉庫(Repository)分發第一個事件

這里所說的復雜的 repositories 就是在文章一開始給大家看的示例中的 Repository。由于復雜 Repository 相關知識點比較多，我會在后續文章中詳細介紹

Repository 的創建和使用

Agera 提供了一個 Repositories 工具類來幫助我們創建 Repository

Repositories 類提供個三個靜態方法，分別對應上面介紹的三種 Repository 的創建

//根據傳入的值創建一個Repository
public static <T> Repository<T> repository(@NonNull final T object)

//根據傳入的值創建一個可修改值的Repository(即 MutableRepository )
public static <T> MutableRepository<T> mutableRepository(@NonNull final T object)

//根據傳入值作為初始值，聲明一個復雜Repository(即CompiledRepository)的創建的開始
public static <T> REventSource<T, T> repositoryWithInitialValue(@NonNull final T initialValue)

簡單Repository 的創建和使用

//創建一個靜態的Rpository(即倉庫中的值不能改變)
 Repository<Integer> integerRepository = Repositories.repository(666);
  //輸出值為 666
 Log.d("tag", "integerRepository " + integerRepository.get());


 //創建可修改值的Repository(即 MutableRepository )
 MutableRepository<Integer> mutableRepository = Repositories.mutableRepository(888);
 //輸出為 888
 Log.d("tag", "mutableRepository " + mutableRepository.get());

 //通過accept方法改變倉庫中的值
 mutableRepository.accept(999);
 //輸出為 999
 Log.d("tag", "mutableRepository " + mutableRepository.get());

到這里，我們學到了如何去創建一個Repository ，并且根據我們的需要去 更新 / 獲取 Repository 中的值

還記得上面點擊按鈕改變文字那個例子嗎？現在我們用 Repository 改進一下： 當我們點擊按鈕的時候，文字上顯示出當前的時間，精確到秒

實現思路：

  1. 創建一個 Updatable (觀察者) 和一個 MutableRepository (被觀察者&& 數據提供者)
  2. 為數據倉庫 MutableRepository 添加一個觀察者 Updatable
  3. 當點擊按鈕時，更新倉庫 MutableRepository 中的值
  4. 由于 MutableRepository 中的值發送了改變，此時 Updatable 會收到更新事件，在 update() 方法中獲取到 MutableRepository 中的最新值，并顯示出來
  5. 在不使用時注銷 Updatable

代碼如下：

public class SimpleActivity extends Activity {
    Button btnTest;
    TextView tvHello;
    DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.CHINA);

    //1. 創建一個 Updatable (觀察者)
    Updatable updatable = new Updatable() {
        @Override
        public void update() {
            //4. 從數據倉庫中獲取數據
            String currentTime = mutableRepository.get();
            tvHello.setText(currentTime);
        }
    };

    //1. 創建一個 MutableRepository (被觀察者&& 數據提供者)
    MutableRepository<String> mutableRepository = Repositories.mutableRepository(getCurrentTime());

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_simple);

        btnTest = findViewById(R.id.btnTest);
        tvHello = findViewById(R.id.tvHello);

        //3. 當點擊按鈕時，更新倉庫 MutableRepository  中的值
        btnTest.setOnClickListener(v -> mutableRepository.accept(getCurrentTime()));
    }

    @Override
    protected void onResume() {
        super.onResume();
        //2. 為數據倉庫 MutableRepository 添加一個觀察者 Updatable
        mutableRepository.addUpdatable(updatable);
    }

    @Override
    protected void onPause() {
        super.onPause();
        //5. 移除觀察者
        mutableRepository.removeUpdatable(updatable);
    }

    private String getCurrentTime() {
        return format.format(new Date());
    }
}

運行看一下效果，當我們點擊按鈕時，會顯示當前的時間:


顯示時間.gif

看到這里不知道小伙伴有沒有疑問，就是為什么當MutableRepository 的值改變的時候(也就是我們點擊按鈕)，Updatable 會接收到更新事件？

其實是這樣的，MutableRepository 只是一個接口。當我們用Repositories.mutableRepository(getCurrentTime())的時候，真正創建的是一個 SimpleRepository 對象。 這個對象繼承了 BaseObservable 類，并且實現了 MutableRepository接口。BaseObservable 類中幫我們做了處理，當倉庫中的值改變的時候(也就是調用了 mutableRepository.accept() ) 方法后，如果接收的新值與原有的舊值不相同的話，就去通知注冊過的 Updatable 更新

這一部分內容如果你還不了解的話，可以先不用深究，知道如何使用就好。后續文章會解析相關源碼

注意： BaseObservable 中判斷新舊值是否相等使用的是 boolean equals(Object obj) 方法

注意：Updatable 的注冊和注銷必須配對使用。在有聲明周期的地方，比如 Activity，就可以在 onResume、onPause 等回調方法去添加/注銷 Updatable

這里在給大家留一個小的思考題，上面的例子，我們是點擊按鈕后更新當前時間并顯示出來，現在要求不用點擊按鈕，并且時間一直在更新(類似電子鐘表)。該如何實現呢？你可以嘗試自己實現一下。如果有疑問可以留言與我交流

五、 總結

這里我們做一下總結：

  1. Agera 是基于 觀察者模式 的。在 Agera 中，Updatable 指代的是觀察者模式中的觀察者， Observable 所指代的就是觀察者模式中的被觀察者
  2. Supplier 接口定義了 提供 一個數據的能力
  3. Receiver 定義了 接收 一個數據的能力
  4. Repository 是一個 擁有提供數據能力的被觀察者
  5. MutableRepository 是一個 擁有 提供/更新 數據能力的被觀察者
  6. 簡單的 Repository 通過 Repositories 類中的靜態方法去創建(創建出來的對象實際上是 SimpleRepository 對象)
  7. 當 MutableRepository 中的值 改變 的時候（值的改變是通過equals方法判斷的），會通知所有注冊過的 Updatable 更新（這個操作是在 BaseObservable 中處理的）

下面我用一張表格對本文中所講到的類/接口再做一個總結：

類/接口 描述 作用
Updatable 觀察者 更新事件
Observable 被觀察者 添加/刪除Updatable
Supplier 數據提供者 提供一個數據
Receiver 數據接收者 接收一個數據
Repository 擁有提供數據能力的被觀察者 添加/刪除Updatable、提供一個數據
MutableRepository 擁有 提供/更新 數據能力的被觀察者 添加/刪除Updatable、提供/更新一個數據

六、相關代碼

https://github.com/smashinggit/Study

注：此工程包含多個module，本文所用代碼均在AgeraDemo下

七、預告

由于篇幅有限，這篇文章只是給小伙伴們介紹了 Agera 的基本概念和基本使用。在后面的文章中，將會詳細介紹 Repository 的具體使用，敬請期待~

后續文章已經更新啦~
Android官方響應式框架Agera詳解：二、Repository的創建和操作符

注：由于本人水平有限，所以難免會有理解偏差或者使用不正確的問題。如果小伙伴們有更好的理解或者發現有什么問題，歡迎留言批評指正~

最后編輯于 ：
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。