Android Architecture Components 只看這一篇就夠了

本文由玉剛說寫作平臺提供寫作贊助

原作者：Boy·哈利波特

版權宣告：本文版權歸微信公眾號 玉剛說 所有，未經許可，不得以任何形式轉載

一、前言

---

1.1、Android Architecture Components 介紹

Android Architecture Components 是谷歌在Google I/O 2017釋出一套幫助開發者解決Android 架構設計的方案。裡面包含了兩大塊內容：

• 生命週期相關的 Lifecycle-aware Components
• 資料庫解決方案 Room

1.2、元件功能

官方給予 Google 元件的功能：A collection of libraries that help you design robust, testable, and maintainable apps. Start with classes for managing your UI component lifecycle and handling data persistence。

使用Google 提供的處理資料持久化和管理元件生命週期的類，有助於應用開發者們構建更加魯棒性，可測的，穩定可靠的應用。

提供主要的元件有：

• Lifecycle：管理元件生命週期
• Room: 持久化資料結構

1.3、主要架構

1.4、使用元件

在專案根目錄 build.gradle 檔案新增倉庫依賴：

allprojects {
    repositories {
        jcenter()
        google()
    }
}
複製程式碼

如果遇到如下因 gradle 版本導致的編譯失敗問題：

Error:(6, 1) A problem occurred evaluating root project `TestArc`.>
Could not find method google() for arguments [] on repository container；
複製程式碼

可修改為：

maven {
   url `https://maven.google.com`
}
複製程式碼

然後在主 module 的 build.gradle 檔案新增需要依賴的元件：

dependencies {
    compile fileTree(dir: `libs`, include: [`*.jar`])
    androidTestCompile(`com.android.support.test.espresso:espresso-core:2.2.2`, {
        exclude group: `com.android.support`, module: `support-annotations`
    })
    compile `com.android.support:appcompat-v7:26.+`

    def lifecycle_version = "1.1.1"

    // ViewModel and LiveData
    compile "android.arch.lifecycle:extensions:$lifecycle_version"
    // alternatively - just ViewModel
    compile "android.arch.lifecycle:viewmodel:$lifecycle_version" // use -ktx for Kotlin
    // alternatively - just LiveData
    compile "android.arch.lifecycle:livedata:$lifecycle_version"
    // alternatively - Lifecycles only (no ViewModel or LiveData).
    // Support library depends on this lightweight import
    compile "android.arch.lifecycle:runtime:$lifecycle_version"

    annotationProcessor "android.arch.lifecycle:compiler:$lifecycle_version"
    // alternately - if using Java8, use the following instead of compiler
    compile "android.arch.lifecycle:common-java8:$lifecycle_version"

    // optional - ReactiveStreams support for LiveData
    compile "android.arch.lifecycle:reactivestreams:$lifecycle_version"

    // optional - Test helpers for LiveData
    // compile "android.arch.core:core-testing:$lifecycle_version"
    compile `com.squareup.retrofit2:retrofit:2.1.0`

    compile `com.squareup.retrofit2:converter-gson:2.1.0`
    compile `com.facebook.stetho:stetho:1.3.1`

    //  room
    compile `android.arch.persistence.room:runtime:1.1.0`
    annotationProcessor `android.arch.persistence.room:compiler:1.1.0`
    compile "android.arch.persistence.room:rxjava2:1.1.0"
}
複製程式碼

二、Lifecycle 管理生命週期

---

2.1、Lifecycle 介紹

Lifecycle 元件指的是 android.arch.lifecycle 包下提供的各種類與介面，可以讓開發者構建能感知其他元件（主要指Activity 、Fragment）生命週期（lifecycle-aware）的類。

2.2、常規 MVP Presenter 使用

比如我們需要監聽某個 Activity 生命週期的變化，在生命週期改變的時候列印日誌，一般做法構造回撥的方式，先定義基礎 BaseActivityPresenter 介面：

public interface BaseActivityPresenter extends BasePresenter{

    void onCreate();

    void onStart();

    void onResume();

    void onPause();

    void onStop();

    void onDestroy();

}
複製程式碼

在實現類中增加自定義操作（列印日誌）：

public class ActivityPresenter implements BaseActivityPresenter {

    private static String TAG = ActivityPresenter.class.getSimpleName();

    @Override
    public void onCreate() {
        LogUtil.i(TAG, "onCreate()");
    }

    @Override
    public void onStart() {
        LogUtil.i(TAG, "onStart()");
    }

    @Override
    public void onResume() {
        LogUtil.i(TAG, "onResume()");
    }

    @Override
    public void onPause() {
        LogUtil.i(TAG, "onPause()");
    }

    @Override
    public void onStop() {
        LogUtil.i(TAG, "onStop()");
    }

    @Override
    public void onDestroy() {
        LogUtil.i(TAG, "onDestroy()");
    }

}
複製程式碼

然後在需要監聽的 Activity 中依次回撥方法：

@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mBasePresenter = new ActivityPresenter();
    }

    @Override
    protected void onStart() {
        super.onStart();
        mBasePresenter.onStart();
    }

    @Override
    protected void onResume() {
        super.onResume();
        mBasePresenter.onResume();
    }

    @Override
    protected void onPause() {
        super.onPause();
        mBasePresenter.onPause();
    }

    @Override
    protected void onStop() {
        super.onStop();
        mBasePresenter.onStop();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        mBasePresenter.onDestroy();
    }
複製程式碼

在 Activity 的 onCreate() 方法中建立 BasePresenter，監聽 Activity 的生命週期方法。

2.3、使用 Lifecycle

上述寫可以實現基礎的功能，但是不夠靈活，假如除了 ActivityPresenter 類，還有別的類要監聽 Activity 生命週期變化，那也需要新增許多生命週期的回撥方法，比較繁瑣。那我們是否可以當 Activity 生命週期發生變化的時候主動通知需求方呢？答案就是使用 Lifecycle 提供的 LifecycleObserver：

public class ActivityLifeObserver implements BaseActivityPresenter,
 LifecycleObserver {

    private String TAG = ActivityLifeObserver.class.getSimpleName();

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    @Override
    public void onCreate() {
        LogUtil.i(TAG, "onCreate()");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    @Override
    public void onStart() {
        LogUtil.i(TAG, "onStart()");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    @Override
    public void onResume() {
        LogUtil.i(TAG, "onResume()");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    @Override
    public void onPause() {
        LogUtil.i(TAG, "onPause()");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    @Override
    public void onStop() {
        LogUtil.i(TAG, "onStop()");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    @Override
    public void onDestroy() {
        LogUtil.i(TAG, "onDestroy()");
    }

}
複製程式碼

讓我們的業務類實現 ActivityLifeObserver 介面，同時在每一個方法實現上增加 @OnLifecycleEvent(Lifecycle.Event.XXXX）註解，OnLifecycleEvent 對應了 Activity 的生命週期方法。被監聽的 Actiivty 實現 LifecycleOwner 介面，然後在需要監聽的 Activity 中註冊：

public class DetailActivity extends AppCompatActivity implements LifecycleOwner{

    private static String TAG = DetailActivity.class.getSimpleName();
    private LifecycleRegistry mLifecycleRegistry;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_detail);
        mLifecycleRegistry = new LifecycleRegistry(this);
        // 註冊需要監聽的 Observer 
        mLifecycleRegistry.addObserver(new ActivityLifeObserver());
        mLifecycleRegistry.addObserver(new LocationLifeObserver());
    }

    @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
}
複製程式碼

執行如下：

com.troy.androidrc I/ActivityLifeObserver: onCreate()
com.troy.androidrc I/ActivityLifeObserver: onStart()
com.troy.androidrc I/ActivityLifeObserver: onResume()
com.troy.androidrc I/ActivityLifeObserver: onPause()
com.troy.androidrc I/ActivityLifeObserver: onStop()
com.troy.androidrc I/ActivityLifeObserver: onDestroy()
複製程式碼

其中 Lifecycle 使用兩個主要的列舉類來表示其所關聯元件的生命週期：

• Event 事件 從元件或者Lifecycle類分發出來的生命週期，它們和Activity／Fragment生命週期的事件一一對應。(ON_CREATE, ON_START, ON_RESUME, ON_PAUSE, ON_STOP, ON_DESTROY)；
• State 狀態 當前元件的生命週期狀態(INITIALIZED, DESTROYED, CREATED, STARTED, RESUMED)。

LifecycleRegistry 類用於註冊和反註冊需要觀察當前元件生命週期的 Observer，用法如下：

//  初始化
mLifecycleRegistry = new LifecycleRegistry(this);
mActivityLifeObserver = new ActivityLifeObserver();
//  註冊觀察者
mLifecycleRegistry.addObserver(mActivityLifeObserver);
mLifecycleRegistry.addObserver(new LocationLifeObserver());
//  移除觀察者
mLifecycleRegistry.removeObserver(mActivityLifeObserver);
複製程式碼

三、LiveData && ViewModel

---

3.1、LiveData && ViewModel 介紹

LiveData 是一種持有可被觀察資料的類（an observable data holder class）。和其他可被觀察的類不同的是，LiveData是有生命週期感知能力的（lifecycle-aware,），這意味著它可以在 activities, fragments, 或者 services 生命週期是活躍狀態時更新這些元件。

ViewModel 與 LiveData 之間的關係圖如下：

3.2、LiveData && ViewModel 使用

在 Activity 頁面有一 TextView，需要展示使用者 User 的資訊，User 類定義：

public class User {

    public String userId;

    public String name;

    public String phone;

    @Override
    public String toString() {
        return "User{" +
                "userId=`" + userId + ``` +
                ", name=`" + name + ``` +
                ", phone=`" + phone + ``` +
                `}`;
    }
}

複製程式碼

常規的做法：

// 獲取 User 的資料後
mTvUser.setText(user.toString());
複製程式碼

這樣做的一個問題，如果獲取或者修改 User 的來源不止一處，那麼需要在多個地方更新 TextView，並且如果在多處 UI 用到了 User，那麼也需要在多處更新。

使用 LiveData 與 ViewModel 的組合，將LiveData 持有 User 實體，作為一個被觀察者，當 User 改變時，所有使用 User 的地方自動 change。構建一個 UserViewModel 如下：

public class UserViewModel extends ViewModel
 implements BaseViewModel<User> {

    private String TAG = UserViewModel.class.getSimpleName();

    private MutableLiveData<User> liveUser;

    public MutableLiveData<User> getData(){
        if(liveUser == null){
            liveUser = new MutableLiveData<User>();
        }

        liveUser.setValue(loadData());
        return this.liveUser;
    }

    public void changeData(){
        if(liveUser != null){
            liveUser.setValue(loadData());
        }
    }

    @Override
    public User loadData() {
        User user = new User();
        user.userId = RandomUtil.getRandomNumber();
        user.name = RandomUtil.getChineseName();
        user.phone = RandomUtil.getRandomPhone();
        LogUtil.i(TAG, "loadData(): " + user.toString());
        return user;
    }

    @Override
    public void clearData() {

    }
}
複製程式碼

自定義的UserViewModel 繼承系統的 ViewModel，將 User 封裝成 MutableLiveData：
if(liveUser == null){ liveUser = new MutableLiveData<User>(); }

在使用User 的地方增加觀察：

//  view model.observe
mUserViewModel = ViewModelProviders.of(this).get(UserViewModel.class);
mUserViewModel.getData().observe(this, new Observer<User>() {
   @Override
   public void onChanged(@Nullable User user) {
       if(user != null){
           mTvUser.setText(user.toString());
       }
   }
});
複製程式碼

資料來源傳送改變的時候：

//	改變 User 內容
mButtonUser.setOnClickListener(new View.OnClickListener() {
     @Override
     public void onClick(View v) {
         if(mUserViewModel != null && mUserViewModel.getData() != null){
             mUserViewModel.changeData();
         }
     }
});

//	setValue
public void changeData(){
   if(liveUser != null){
        liveUser.setValue(loadData());
    }
}
複製程式碼

這樣使用到 User 的地方，UI 會自動更新，日誌如下：

com.troy.androidrc I/DetailActivity:
 User{userId=`9372622`, name=`鄧楠`, phone=`15607043749`}

com.troy.androidrc I/DetailActivity:
 User{userId=`6099877`, name=`文瑾慧`, phone=`13005794027`}

複製程式碼

四、Room

---

4.1、Room 介紹

Room 持久層庫提供了一個方便我們訪問 SQLite 資料庫的抽象層(an abstraction layer )，幫助我們更好的在 APP 上建立我們的資料快取，能夠讓 APP 即使在沒有網路的情況也能正常使用。

Room 的架構如下：

4.2、Room 使用與主要註解

建立包含訂單表的資料庫如下步驟：

1、建立 Order.java:

@Entity(tableName = "orders")
public class Order {

    @PrimaryKey
    @ColumnInfo(name = "order_id")
    public long orderId;

    @ColumnInfo(name = "address")
    public String address;

    @ColumnInfo(name = "owner_name")
    public String ownerName;

    @ColumnInfo(name = "owner_phone")
    public String ownerPhone;

    //  指示 Room 需要忽略的欄位或方法
    @Ignore
    public String ignoreText;

    @Embedded
    public OwnerAddress ownerAddress;
}
複製程式碼

2、建立 OrderDao：

@Dao
public interface OrderDao {

    @Query("SELECT * FROM orders")
    List<Order> loadAllOrders();

    @Insert
    void insertAll(Order... orders);

    @Query("SELECT * FROM orders WHERE order_id IN (:orderIds)")
    List<Order> queryOrderById(long[] orderIds);

    @Delete
    void deleteOrder(Order... orders);

    @Update
    void updateOrder(Order... orders);
}
複製程式碼

3、建立資料庫

@Database(entities = {Order.class, AddressInfo.class}, version = 2)
public abstract class AppDatabase extends RoomDatabase{

   public abstract OrderDao getOrderDao();
   
}

// 實現類
public static void buildDb(){
DB_INSTANCE = Room.
    databaseBuilder(TroyApplication.getInstance(), AppDatabase.class, "troy_db")   //  指定資料庫名稱
    .addCallback(new RoomDatabase.Callback() {
        @Override
        public void onCreate(@NonNull SupportSQLiteDatabase db) {
            super.onCreate(db);  //  資料庫建立回撥；
            LogUtil.i(TAG, "onCreate");
        }

        @Override
        public void onOpen(@NonNull SupportSQLiteDatabase db) {
            super.onOpen(db);   //  資料庫使用回撥；
            LogUtil.i(TAG, "onOpen");
        }
    })
    .allowMainThreadQueries()   // 資料庫操作可執行在主執行緒
    .build();

}
複製程式碼

使用到的主要註解：

• @Entity(tableName = “orders”) // 定義表名；
• @PrimaryKey // 定義主鍵；
• @ColumnInfo(name = “order_id”) // 定義資料表中的欄位名；
• @Ignore // 指示 Room 需要忽略的欄位或方法；
• @Embedded // 指定嵌入實體
• @Query(“SELECT * FROM orders”) // 定義查詢資料介面；
• @Insert // 定義增加資料介面；
• @Delete // 定義刪除資料介面；
• @Update // 定義更新資料介面；
• @Database // 定義資料庫資訊，表資訊，資料庫版本

3.3、增刪改查實現

增：

//  1、插入介面宣告
@Insert
void insertAll(Order... orders);

//  2、插入介面實現
@Override
  public void insertAll(Order... orders) {
    __db.beginTransaction();
    try {
      __insertionAdapterOfOrder.insert(orders);
      __db.setTransactionSuccessful();
    } finally {
      __db.endTransaction();
    }
}

//  3、插入介面呼叫
AppDatabase db = DbManager.getDbInstance();
OrderDao orderDao = db.getOrderDao();
Order order = Order.createNewOrder();
orderDao.insertAll(order);
複製程式碼

刪：

//	1、刪除介面宣告
@Delete
void deleteOrder(Order... orders);

//	2、刪除介面實現
@Override
  public void deleteOrder(Order... orders) {
    __db.beginTransaction();
    try {
      __deletionAdapterOfOrder.handleMultiple(orders);
      __db.setTransactionSuccessful();
    } finally {
      __db.endTransaction();
    }
}

//	3、刪除介面呼叫
AppDatabase db = DbManager.getDbInstance();
OrderDao orderDao = db.getOrderDao();
orderDao.deleteOrder(orderList.get(orderList.size() - 1));
複製程式碼

改：

//	1、修改介面宣告
 @Update
 void updateOrder(Order... orders);

//	2、修改介面實現
@Override
  public void updateOrder(Order... orders) {
    __db.beginTransaction();
    try {
      __updateAdapterOfOrder.handleMultiple(orders);
      __db.setTransactionSuccessful();
    } finally {
      __db.endTransaction();
    }
}

//	3、修改介面呼叫
AppDatabase db = DbManager.getDbInstance();
OrderDao orderDao = db.getOrderDao();
Order order = orderList.get(orderList.size() - 1);
order.ownerName = "update - " + RandomUtil.getChineseName();
orderDao.updateOrder(order);
複製程式碼

查：

//	1、查詢介面宣告
@Query("SELECT * FROM orders")
List<Order> loadAllOrders();

//	2、查詢介面實現
@Override
  public List<Order> loadAllOrders() {
    final String _sql = "SELECT * FROM orders";
    final RoomSQLiteQuery _statement = RoomSQLiteQuery.acquire(_sql, 0);
    final Cursor _cursor = __db.query(_statement);
    try {
      final int _cursorIndexOfOrderId = _cursor.getColumnIndexOrThrow("order_id");
      final int _cursorIndexOfAddress = _cursor.getColumnIndexOrThrow("address");
      final int _cursorIndexOfOwnerName = _cursor.getColumnIndexOrThrow("owner_name");
      final int _cursorIndexOfOwnerPhone = _cursor.getColumnIndexOrThrow("owner_phone");
      final int _cursorIndexOfStreet = _cursor.getColumnIndexOrThrow("street");
      final int _cursorIndexOfState = _cursor.getColumnIndexOrThrow("state");
      final int _cursorIndexOfCity = _cursor.getColumnIndexOrThrow("city");
      final int _cursorIndexOfPostCode = _cursor.getColumnIndexOrThrow("post_code");
      final List<Order> _result = new ArrayList<Order>(_cursor.getCount());
      while(_cursor.moveToNext()) {
        final Order _item;
        final Order.OwnerAddress _tmpOwnerAddress;
        if (! (_cursor.isNull(_cursorIndexOfStreet) && _cursor.isNull(_cursorIndexOfState) && _cursor.isNull(_cursorIndexOfCity) && _cursor.isNull(_cursorIndexOfPostCode))) {
          _tmpOwnerAddress = new Order.OwnerAddress();
          _tmpOwnerAddress.street = _cursor.getString(_cursorIndexOfStreet);
          _tmpOwnerAddress.state = _cursor.getString(_cursorIndexOfState);
          _tmpOwnerAddress.city = _cursor.getString(_cursorIndexOfCity);
          _tmpOwnerAddress.postCode = _cursor.getInt(_cursorIndexOfPostCode);
        }  else  {
          _tmpOwnerAddress = null;
        }
        _item = new Order();
        _item.orderId = _cursor.getLong(_cursorIndexOfOrderId);
        _item.address = _cursor.getString(_cursorIndexOfAddress);
        _item.ownerName = _cursor.getString(_cursorIndexOfOwnerName);
        _item.ownerPhone = _cursor.getString(_cursorIndexOfOwnerPhone);
        _item.ownerAddress = _tmpOwnerAddress;
        _result.add(_item);
      }
      return _result;
    } finally {
      _cursor.close();
      _statement.release();
    }
  }

//	3、查詢介面呼叫
AppDatabase db = DbManager.getDbInstance();
OrderDao orderDao = db.getOrderDao();
return orderDao.loadAllOrders();
複製程式碼

3.4、內嵌實體

如果實體 Order 內部包含地址資訊，地址資訊分別包含 城市，郵政等資訊，可以這樣寫，使用@Embedded 註解：

static class OwnerAddress {

        public String street;
        public String state;
        public String city;

        @ColumnInfo(name = "post_code")
        public int postCode;
}

@Embedded
public OwnerAddress ownerAddress;
複製程式碼

3.5、配合 LiveData

資料查詢可以返回 LiveData 資料：

 @Query("SELECT * FROM orders")
 LiveData<List<Order>> loadAllOrderData();
複製程式碼

3.6、配合 RxJava

通過 query 查詢返回的實體，可以封裝成 對應RxJava 的操作符封裝物件，例如 Flowable，Maybe 等：

//	介面宣告
@Query("SELECT * from orders where order_id = :id LIMIT 1")
Flowable<Order> queryOrderByIdV2(long id);

@Query("SELECT * from orders where order_id = :id LIMIT 1")
Maybe<Order> queryOrderByIdV3(long id);

// 介面呼叫
private Maybe<Order> queryOrderV3(){
      AppDatabase db = DbManager.getDbInstance();
      OrderDao orderDao = db.getOrderDao();
      return orderDao.queryOrderByIdV3(10001);
}

Maybe<Order> orderMaybe = queryOrderV3();
        orderMaybe.subscribeOn(Schedulers.io())
             .observeOn(Schedulers.newThread())
             .subscribe(new Consumer<Order>() {
                 @Override
                 public void accept(@NonNull Order order) throws Exception {

                 }
});
複製程式碼

以上程式碼Demo 實現：

五、總結

學會使用 Android Architecture Components 提供的元件簡化我們的開發，能夠使我們開發的應用模組更解耦更穩定，檢視與資料持久層分離，以及更好的擴充套件性與靈活性，

參考致謝：

1. Architechture
2. Lifecycle package class
3. Save data in a local database using Room
4. Android Room with a View
5. Google Samples