利用 LiveData 和 ViewModel 搭建应用内数据中心

背景

在 App 中，存在这样几组数据，需要在所有 Activity 和 Fragment 间共享，也可以被任意对象访问，被访问时，如果数据没有初始化，就会先进行初始化，数据准备完毕后再传递给访问者。实现方式有多种，比如利用 RxJava 将各组数据设计成可观察对象。这里我们采用了 LiveData 和 ViewModel ，因为在 Android 平台，它们有着自己独特的优势。

LiveData

LiveData 是能感知生命周期的，它遵循宿主（如 Activity，Fragment，Service）的生命周期，仅会在宿主生命周期激活时，才会通知更新数据，使用 LiveData 也有以下的优势：

• 能及时更新宿主数据状态

• 没有内存泄漏

• 不会再有当宿主处于 onStop 时更新数据可能造成 crash 的情况

• 无需手动处理生命周期

• 始终保持数据最新
  ...

LiveData 常用的有下面几种方法：

getValue()

获取当前数据

observe(LifecycleOwner owner, Observer<T> observer)

在 Lifecycle 宿主中订阅 LiveData

setValue(T value)

更新数据，注意此方法只能在主线程调用

postValue(T value)

更新数据，此方法允许在异步线程中调用

ViewModel

ViewModel 能很好的为 Activity 和 Fragment 管理数据，将数据相关的操作与 UI 层分离。
...

实现

首先定义 Data，能在应用内任意访问的数据。

interface Data {    fun isEmpty(): Boolean

    fun refresh()}

这里看到其中定义了两个方法，isEmpty()， 用来判断该数据是否为空，refresh()，用来更新数据自身，比如拉取远端的最新数据，或从数据库读取。

接下来以用户数据为例，首先创建一个 User 类来定义数据结构：

data class User(var userId: Int, var userName: String, var userEmail: String) {    fun isEmpty(): Boolean = userId.isNullOrBlank() && userName.isNullOrBlank() && userEmail.isNullOrBlank()
}

这里 User 类持有了用户 Id, 用户名和用户邮箱。接下来定义 UserData：

class UserData: LiveData<User>(), Data {

    override fun isEmpty(): Boolean {        return value == null || value.isEmpty()
    }

    override fun refresh() {        //异步拉取最新数据
        asyncLoadData(newData -> 
            //更新
            postValue(newData)
        )
    }

}

在 asyncLoadData 拉取到数据后，调用 postValue 更新 UserData。

下面我们设计一个数据中心，所有的 Data 都存储在数据中心里：

object DataCentral {    private val safeDataTable = ConcurrentHashMap<String, Data>()    fun accessor() = this@DataCentral

    fun <T: Data> query(clazz: Class<T>): T?{
        val queryKey = clazz.simpleName        if (!safeDataTable.containsKey(queryKey) || safeDataTable[queryKey] == null){            try {
                safeDataTable[queryKey] = clazz.newInstance()
            }catch (e: InstantiationException){                //Data block init error
                ...                return null
            }catch (e: IllegalAccessException){                //Data block init error
                ...                return null
            }catch (e: ExceptionInInitializerError){                //Data block init error
                ...                return null
            }catch (e: SecurityException){                //Data block init error
                ...                return null
            }catch (e: Exception){
                ...
            }
        }        return safeDataTable[queryKey] as? T
    }

}

从上面的代码中，可以看到所有的 Data 其实存储在了一个 HashMap 里，这里采用了 ConcurrentHashMap 以支持并发操作。另外我们以具体 Data 类的类名来作为存储的 Key，这样避免在数据量大时，需要维护相当数量的 key。每一组数据也只会在首次被访问时，才会在数据中心创建，创建的方式是通过无参构造函数直接新建实例，所以在定义每个 Data 时，需要包含一个无参的构造函数。

现在数据中心有了，我们还需要一个媒介，用来访问数据中心，同时承担与数据中心交互以外的部分职责，就像一个代理。显然该 ViewModel 出场了：

class DataCentralAgent: ViewModel() {    private val dataCentralAccessor = DataCentral.accessor()

    fun <T: Data> get(clazz: Class<T>): T?{        return dataCentralAccessor.query(clazz)?.apply {            if (isEmpty()) {
                refresh()
                ...
            }
        }
    }

    override fun onCleared() {
        super.onCleared()
        ...
    }
}

我们看到 get(clazz: Clazz<T>) 方法，传入需要获取的具体 Data 类型，数据中心会将 Data 查询出来并返回，同时对数据进行判空，如果为空，便调用 refresh() 方法更新该数据的值。

那么在 Activity 和 Fragment 中，我们只需要通过 DataCentralAgent 来 get 我们需要的数据就可以了，即使数据还没有准备好，它也会自己默默在后台更新自己，接着借助于 LiveData 的特性将更新好的数据传递给订阅者。我们还可以写一个辅助类，来帮助快速创建 Agent：

object DataCentralAgentFactory {

    @MainThread
    fun createFor(activityOwner: FragmentActivity): DataCentralAgent =
            ViewModelProviders.of(activityOwner).get(DataCentralAgent::class.java)

    @MainThread
    fun createFor(fragmentOwner: Fragment): DataCentralAgent =
            ViewModelProviders.of(fragmentOwner).get(DataCentralAgent::class.java)}

下面我们写一个访问示例:

class MyFragment: Fragment {

      override fun onCreate(savedInstanceState: Bundle?) {
        DataCentralAgentFactory
              .createFor(this)
              .get(UserData::class.java)
              ?.observe(this@MyFragment, object: Observer<User> {
                  override fun onChanged(user: User?) {
                     ...
                  }
              })  
        super.onCreate(savedInstanceState)
        ...
      }
      
}

作者：明月几时有__
链接：https://www.jianshu.com/p/269dc6e6a9aa