文章详细的介绍了2022 Android 官方架构指南，对于中高级的开发者而言都具有很高的价值。文章主要分以下几个部分：
概述
📌 名词解释
DataSource：数据源类，是 App 中业务逻辑与系统 API 和三方 SDK 的桥接类。Repository：数据仓库类，其使用DataSource处理业务逻辑，并将数据提供给上层调用者的类。
Data Layer 主要做了下面两件事情：
通过
DataSource封装系统及三方 API；通过
Repository使用DataSource封装业务逻辑，并暴露给使用者；
因此，Data Layer 主要也是由 DataSource 与 Repository 组成。
想要将以上述两件事情做好，我们就是需要搞清楚两者的定义以及其如何协作，也就是要回答下述的几个问题：
如何定义及封装
DataSource？如何定义及封装
Repository？DataSource与Repository之间如何交互？
这篇文章主要要解决的也是上面的几个问题。好的，下面我们就是进入主题。首先看一下两者分别是如何定义的的。
如何定义及封装 DataSource？
DataSource 主要做了以下几件事情：
封装系统 API，如文件读写、位置信息；
封装系统库及三方库 API，如 Okhttp、Retrofit、Room 等；
每个 DataSource 仅处理一种数据类型的数据，该数据源可以是文件、网络来源或本地数据库。根据其来源，又可以将其分为：LocalDataSource、RemoteDataSource 等类型。
其命名规范如下：
DataSource 命名规范
📌 DataSource 命名规范：
DataSource以其负责的数据以及使用的来源命名。具体命名惯例如下：
数据类型 + 来源类型 + DataSource。
对于数据的类型，可以使用 Remote 或 Local，以使其更加通用，因为实现是可以变化的。例如：NewsRemoteDataSource 或 NewsLocalDataSource。在来源非常重要的情况下，为了更加具体，可以使用来源的类型。例如：NewsNetworkDataSource 或 NewsDiskDataSource。
请勿根据实现细节来为数据源命名（例如 UserSharedPreferencesDataSource），因为使用相应数据源的存储库应该不知道数据是如何保存的。如果您遵循此规则，便可以更改数据源的实现（例如，从 SharedPreferences 迁移到 DataStore），而不会影响调用相应数据源的层。
创建 DataSource
以请求网络接口为例，实例如下：
class NewsRemoteDataSource(
private val newsApi: NewsApi,
private val ioDispatcher: CoroutineDispatcher
){
/**
* 在 IO 线程中，获取网络数据，在主线程调用是安全的
*/
suspend fun fetchLatestNews(): List<ArticleHeadline> = withContext(ioDispatcher) {
// 将耗时操作移动到 IO 线程中
newsApi.fetchLatestNews()
}
}
interface NewsApi {
fun fetchLatestNews(): List<ArticleHeadline>
}
暴露接口
系统 API 及大部分三方 SDK 大都是以 Callback 的形式返回数据，为了统一与简化使用，我们可以使用 Kotlin 协程对其进行封装简化。以获取系统位置信息为例，可以使用 suspendCoroutine 或者suspendCancellableCoroutine 将其转换为 suspend 函数了，如下：
class LocationDataSource {
// 将系统的 Callback 类型函数，使用 suspendCoroutine 封装为 suspend 函数
suspend fun awaitLastLocation(): Location =
suspendCoroutine<Location> { continuation ->
lastLocation.addOnSuccessListener { location ->
continuation.resume(location)
}.addOnFailureListener { e ->
continuation.resumeWithException(e)
}
}
这种方式只能处理单次异步的数据请求，对于流失数据请求，可以使用 callbackFlow 来处理，如下：
class LocationDataSource {
// 将系统的 Callback 类似数据流，使用 callbackFlow 封装为 Flow 函数
fun locationFlow(): Flow<Location> = callbackFlow {
val callback = object : LocationCallback() {
override fun onLocationResult(result: LocationResult?) {
result ?: return
for (location in result.locations) {
offer(location) // emit location into the Flow using ProducerScope.offer
}
}
}
requestLocationUpdates(createLocationRequest(), callback, Looper.getMainLooper()).addOnFailureListener { e ->
close(e) // in case of exception, close the Flow
}
awaitClose {
removeLocationUpdates(callback) // clean up when Flow collection ends
}
}
}
更多内容可参考官方 Codelabs 。
实体定义
DataSource 中一般都会将数据通过实体类的方式对外暴露，此部分的定义需要根据其业务类型做不同的处理：
网络接口请求部分，直接将实体定义为对应的 JSON 实例，不建议缺少字段；
对于系统原生 API 的返回数据，建议满足当前业务需求即可，无需全部保留；
对于数据库（Room）的 Entity，可以根据业务需要自由定义；
DataSource 的几种分类
-
LocalDataSource
DataStore、MMKV、SharedPreferenced
Room、GreenDao
File
-
RemoteDataSource
OkHttp
Retrofit
-
BusinessDataSource
Ble、Bluetooth
GPS
...
下面我们看一下如何定义及封装 Repository。
如何定义及封装 Repository ？
Repository 主要做了一下几件事情：
统一抽象 App 中的数据，集中处理，并对上层暴露；
并处理不同 DataSource 之间的冲突；
处理业务逻辑；
其命名规范如下：
命名规范
📌 Repository 命名规范：
Repository以其负责的数据命名。具体命名惯例如下：
数据类型 + Repository。
例如：NewsRepository、MoviesRepository 或 PaymentsRepository。
创建 Repository
以请求网络接口为例，实例如下：
// DataSource 层的引用通过构造函数传入
class NewsRepositoryImpl(
private val newsRemoteDataSource: NewsRemoteDataSource
): NewsRepository {
override suspend fun fetchLatestNews(): List<ArticleHeadline> =
newsRemoteDataSource.fetchLatestNews()
}
// 应定义为 interface
interface NewsRepository {
suspend fun fetchLatestNews(): List<ArticleHeadline>
}
对外暴露数据
对外暴露的数据分为一次性数据以及随时间变化的数据流，如下：
class ExampleRepository(
private val exampleRemoteDataSource: ExampleRemoteDataSource, // network
private val exampleLocalDataSource: ExampleLocalDataSource // database
) {
// 数据流
val data: Flow<Example> = ...
// 一次性操作
suspend fun modifyData(example: Example) { ... }
}
合并不同的数据源
Repository 中可以整合多个 DataSource，并将其统一处理作为单一信源对外暴露。比如优先从 LocalDataSource 获取新闻信息，然后在从 RemoteDataSource 中获取数据：
class NewsRepositoryImpl(
private val remoteDataSource: NewsRemoteDataSource,
private val localDataSource: NewsLocalDataSource,
) : NewsRepository {
// 添加同步锁，确保其在多线程中是安全的
private val latestNewsMutex = Mutex()
// 将最新的数据缓存在内存中
private var latestNews: List<ArticleApiModel> = emptyList()
suspend fun getLatestNews(): List<ArticleApiModel> {
// 先读取本地数据，如果没有的话，则请求云端数据
val local = localDataSource.getLatestNews()
if (local.isEmpty()) {
val networkResult = remoteDataSource.fetchLatestNews()
// 将网络中的最新数据保存到本地的数据库中
latestNewsMutex.withLock {
localDataSource.saveLatestNews(networkResult)
}
}
return latestNewsMutex.withLock { local }
}
}
为了进一步提高提高用户体验，将 UI 尽可能快的展示给用户，也可以在增加一层内存缓存，如下：
class NewsRepositoryImpl(
private val remoteDataSource: NewsRemoteDataSource,
private val localDataSource: NewsLocalDataSource,
) : NewsRepository {
// 添加同步锁，确保其在多线程中是安全的
private val latestNewsMutex = Mutex()
// 将最新的数据缓存在内存中
private var latestNews: List<ArticleApiModel> = emptyList()
suspend fun getLatestNews(): List<ArticleApiModel> {
// 先判断内存中是否有数据，没有的话，则读取 Local 中的数据
if (latestNews.isEmpty()) {
// 读取本地数据，如果没有的话，则请求云端数据
val local = localDataSource.getLatestNews()
if (local.isEmpty()) {
val networkResult = remoteDataSource.fetchLatestNews()
// 将网络中的最新数据保存到本地缓存及内存中
latestNewsMutex.withLock {
localDataSource.saveLatestNews(networkResult)
}
latestNews = networkResult
}
latestNews = local
}
return latestNewsMutex.withLock { this.latestNews }
}
}
DataSource 与 Repository 之间如何交互？
一个业务模块中可以包含一个或者多个 Repository ，每个 Repository 中包含零个或多个 DataSource，DataSource 根据其来源可以分为 LocalDataSource、RemoteDataSource 等。
依赖管理的方式建议使用 Hilt 或者是 Kion 。
统通规则
线程处理
线程处理的统一原则就是对 UI 线程是安全的，如果是耗时操作请将其切换到非 UI 线程中执行。除了这部分规则之外，还会根据其业务类型的不同有不同的处理方式：
面向 UI 的操作
这部分的作用域通常是 viewModelScope 或者是 lifecycleScope，其作用域会根据生命周期的变化而变化，仅仅保证其在主线程调用是安全的即可。
class NewsRemoteDataSource(
private val newsApi: NewsApi,
private val ioDispatcher: CoroutineDispatcher
) {
/**
* 在 IO 线程中，获取网络数据，在主线程调用是安全的
*/
suspend fun fetchLatestNews(): List<ArticleHeadline> = withContext(ioDispatcher) {
// 将耗时操作移动到 IO 线程中
newsApi.fetchLatestNews()
}
}
面向 App 的操作
面向 App 操作的话，其任务的执行周期要比页面的周期更长，所以需要在页面生命周期销毁之后仍然可以在后台执行，所以需要传入一个全局的 scope，如下：
class NewsRepositoryImpl(
private val remoteDataSource: NewsRemoteDataSource,
// 传入一个外部的 scope，通常其是全局的单例或者是在 Application 中实例化的
private val externalScope: CoroutineScope,
private val ioDispatcher: CoroutineDispatcher
) : NewsRepository {
override suspend fun fetchLatestNews(refresh: Boolean): List<ArticleApiModel> {
return withContext(ioDispatcher) {
// 切换至整个 App 的作用域内，当其调用者被销毁时，其仍会执行
withContext(externalScope.coroutineContext) {
remoteDataSource.fetchLatestNews()
}
}
}
}
更多详细内容可查看 Coroutines & Patterns for work that shouldn’t be cancelled 。
面向业务的操作
面向业务的操作无法取消。它们应该会在进程终止后继续执行。例如，完成上传用户想要发布到其个人资料的照片。对于这部分的业务，需要使用 WorkManager ，其定义如下：
class RefreshLatestNewsWorker(
private val newsRepository: NewsRepository,
context: Context,
params: WorkerParameters
) : CoroutineWorker(context, params) {
override suspend fun doWork(): Result = try {
newsRepository.refreshLatestNews()
Result.success()
} catch (error: Throwable) {
Result.failure()
}
}
Worker 应作为一个数据源进行使用，封装如下：
private const val REFRESH_RATE_HOURS = 4L
private const val FETCH_LATEST_NEWS_TASK = "FetchLatestNewsTask"
private const val TAG_FETCH_LATEST_NEWS = "FetchLatestNewsTaskTag"
class NewsTasksDataSource(
private val workManager: WorkManager
) {
fun fetchNewsPeriodically() {
val fetchNewsRequest = PeriodicWorkRequestBuilder<RefreshLatestNewsWorker>(
REFRESH_RATE_HOURS, TimeUnit.HOURS
).setConstraints(
Constraints.Builder()
.setRequiredNetworkType(NetworkType.TEMPORARILY_UNMETERED)
.setRequiresCharging(true)
.build()
)
.addTag(TAG_FETCH_LATEST_NEWS)
workManager.enqueueUniquePeriodicWork(
FETCH_LATEST_NEWS_TASK,
ExistingPeriodicWorkPolicy.KEEP,
fetchNewsRequest.build()
)
}
fun cancelFetchingNewsPeriodically() {
workManager.cancelAllWorkByTag(TAG_FETCH_LATEST_NEWS)
}
}
注意： WorkManager 也可以执行单次任务，不再此处展开。
提供 API
DataSource 及 Repository 中提到 Kotlin 中的一些提供方式，对应 Java 代码或者是 RxJava 的代码而言，有以下方式：
-
一次性操作
Java：使用RxJava
Single、Maybe或Completable类型All：使用回调
-
数据流操作
Java：RxJava
Observable或Flowable类型。All：使用回调
总结
为了更好的完成上述事情，需要解答下面三个问题：
如何定义及封装
DataSource？如何定义及封装
Repository？DataSource与Repository之间如何交互？
回答这三个问题也是这篇文章的核心目的。
