Android Architecture Components

作者: ModestStorm | 来源:发表于2020-06-21 15:19 被阅读0次

浅谈Android Architecture Component
Android 开源库之架构组件
Android Jetpack组件系列之Architecture
Room ORM 数据库框架
Android Architecture Components
史上最强总结Android Architecture Compo
Android Architecture Components
Android架构之AAC
2018-03-20
AAC 的 Lifecycle 结合 Kotlin Corout

转载自:Android Architecture Components 只看这一篇就够了

一、前言

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、主要架构

image

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

image

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 之间的关系图如下：

image

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.observemUserViewModel = 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();         }     }});//    setValuepublic 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 的架构如下：

image

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：

@Daopublic 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、插入接口声明@Insertvoid 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、删除接口声明@Deletevoid 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;}@Embeddedpublic 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 实现：

image

五、总结

学会使用 Android Architecture Components 提供的组件简化我们的开发，能够使我们开发的应用模块更解耦更稳定，视图与数据持久层分离，以及更好的扩展性与灵活性。

参考致谢：

Architechture
Lifecycle package class
Save data in a local database using Room
Android Room with a View
Google Samples

浅谈Android Architecture Component
浅谈Android Architecture Components 浅谈Android Architecture ...
Android 开源库之架构组件
Android Architecture Components Android Architecture Comp...
Android Jetpack组件系列之Architecture
Android Jetpack组件系列之Architecture Components Architecture ...
Room ORM 数据库框架
Room Persistence Library Android Architecture Components ...
Android Architecture Components
一、前言 1.1、Android Architecture Components 介绍 Android Archi...
史上最强总结Android Architecture Compo
一、前言 1.1、Android Architecture Components 介绍 Android Archi...
Android Architecture Components
本文仅是阅读Android Architecture Components的个人总结。 Android App开发...
Android架构之AAC
一、AAC简介 AAC全称Android Architecture Components，是Android官方推出...
2018-03-20
Android Architecture Components 架构组件官方示例 GithubBrowserSam...
AAC 的 Lifecycle 结合 Kotlin Corout
一. Lifecycle 目前，AAC(Android Architecture Components简称) 已...