Android Architecture Components 只看這一篇就夠了

玉剛說發表於2019-03-03

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

原作者: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、主要架構

Android Architecture Components 只看這一篇就夠了

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)。

Android Architecture Components 只看這一篇就夠了

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 之間的關係圖如下:

Android Architecture Components 只看這一篇就夠了

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 的架構如下:

Android Architecture Components 只看這一篇就夠了

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 只看這一篇就夠了

五、總結

學會使用 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

Android Architecture Components 只看這一篇就夠了
關注我,接收更多一手技術乾貨

相關文章