背景
在 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)
...
}
}
到此一个应用内数据中心就搭建完成了。
（转载请注明出处）
