Android 官方 App 架构指南系列文章

概述

📌 名词解释

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 等。大致依赖关系如下：

Diagram.drawio.svg

依赖管理的方式建议使用 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 之间如何交互？

回答这三个问题也是这篇文章的核心目的。

更多内容会第一时间发布在微信公众号中，欢迎大家关注：

扫码_搜索联合传播样式-标准色版.png

Android 官方现代 App 架构解读 - Data Layer

概述