让 Clean 拯救大型项目

本文旨在把 MVVM 与 Clean 架构结合起来，指导我们怎样使用此架构来编写解耦、可测试和可维护的代码。

为啥要把 Clean 和 MVVM 结合起来

MVVM 旨在把视图（Activity / Fragments）和业务逻辑（ViewModel）拆分出来，这对小型项目已经足够了，但随着代码的增长，ViewModel 会逐渐变得臃肿庞大，对业务逻辑进行职责分离会变得越发吃力。

在这种情况下，MVVM 结合 Clean Architecture 便登场了，它进一步分离了代码的职责，明确地抽象了程序执行的操作逻辑。

注意：其实也可以将 Clean Architecture 与 model-view-presenter (MVP) 架构结合起来。但由于 Android Jetpack 已经提供了内置的 ViewModel，因此我们将使用 MVVM 而不是 MVP。

使用 Clean 带来的优势

代码进一步解耦（最大的优势）
比 MVVM 更容易测试
包结构导航变得容易
工程容易维护
可以更快的添加新 features

Clean 架构带来的缺点

稍微陡峭的学习曲线，所有层如何协同工作可能需要一些时间来理解，特别是如果我们之前基于简单的 MVVM or MVP 模式。
添加了很多额外的类，这对于低复杂度的项目来说并不理想。

data flow

接下来举个例子，允许用户创建新帖子并查看他们创建的帖子列表。为了简单起见，示例中没有使用其他库（如 Hilt、Coroutine 等）。

具有简洁架构的 MVVM 各层，代码分为三个独立的层：

展示层 Present Layer
领域层 Domain Layer
数据层 Data Layer

下面详细介绍每一层。目前，例子中生成的包结构如下所示：

├── UseCase.kt
├── UseCaseHandler.kt
├── UseCasesScheduler.kt
├── UseCasesThreadPoolScheduler.kt
├── data
│   ├── model
│   │   └── Post.kt
│   └── source
│       ├── PostDataRepository.kt
│       ├── PostDataSource.kt
│       ├── local
│       │   └── LocalDataSource.kt
│       └── remote
│           └── RemoteDataSource.kt
├── ui
│   ├── domain
│   │   ├── GetPosts.kt
│   │   └── SavePost.kt
│   └── postlist
│       ├── PostListActivity.kt
│       ├── PostListAdapter.kt
│       └── PostListViewModel.kt
└── utils
    ├── Injection.kt
    └── ViewModelFactory.kt

其实还有很多方法来构建文件/文件夹层次结构。平时更偏好根据功能对项目文件进行分组。这样简洁明了。

Present Layer

Present Layer 包括 Activity、Fragment 和 ViewModel。其中 Activity 应该尽可能单一。永远不要将业务逻辑放在 Activity 当中。
Activity 与 ViewModel 会话，ViewModel 将与 Domain Layer 执行操作。 ViewModel 从不直接与 Data Layer 会话。
这里将一个 UseCaseHandler 和两个 UseCases 传递给的 ViewModel。在这个架构中，UseCase 是一个定义 ViewModel 如何与数据层交互的操作。

代码如下：

class PostListViewModel(
    val useCaseHandler: UseCaseHandler,
    val getPosts: GetPosts,
    val savePost: SavePost
): ViewModel() {

    fun getAllPosts(userId: Int, callback: PostDataSource.LoadPostsCallback) {
        val requestValue = GetPosts.RequestValues(userId)
        useCaseHandler.execute(
            getPosts, 
            requestValue, 
            object : UseCase.UseCaseCallback<GetPosts.ResponseValue> {
                override fun onSuccess(response: GetPosts.ResponseValue) {
                    callback.onPostsLoaded(response.posts)
                }

                override fun onError(t: Throwable) {
                    callback.onError(t)
                }
            }
        )
    }

    fun savePost(post: Post, callback: PostDataSource.SaveTaskCallback) {
        val requestValues = SavePost.RequestValues(post)
        useCaseHandler.execute(
            savePost, 
            requestValues, 
            object : UseCase.UseCaseCallback<SavePost.ResponseValue> {
                override fun onSuccess(response: SavePost.ResponseValue) {
                    callback.onSaveSuccess()
                }
                override fun onError(t: Throwable) {
                    callback.onError(t)
                }
            }
        )
    }

}

Domain Layer

Domain Layer 包含应用程序的所有用例。在此示例中，有 UseCase，一个抽象类。所有的 UseCase 都将扩展这个类。

abstract class UseCase<Q : UseCase.RequestValues, P : UseCase.ResponseValue> {

    var requestValues: Q? = null

    var useCaseCallback: UseCaseCallback<P>? = null

    internal fun run() {
        executeUseCase(requestValues)
    }

    protected abstract fun executeUseCase(requestValues: Q?)

    /**
     * Data passed to a request.
     */
    interface RequestValues

    /**
     * Data received from a request.
     */
    interface ResponseValue

    interface UseCaseCallback<R> {
        fun onSuccess(response: R)
        fun onError(t: Throwable)
    }
}

UseCaseHandler 处理 UseCase 的执行。当从数据库或远程服务器获取数据时，不应该阻塞 UI。这是决定在后台线程上执行 UseCase 并在主线程上接收响应的地方。

class UseCaseHandler(private val mUseCaseScheduler: UseCaseScheduler) {

    fun <T : UseCase.RequestValues, R : UseCase.ResponseValue> execute(
            useCase: UseCase<T, R>, values: T, callback: UseCase.UseCaseCallback<R>) {
        useCase.requestValues = values
        useCase.useCaseCallback = UiCallbackWrapper(callback, this)
        mUseCaseScheduler.execute(Runnable {
            useCase.run()
        })
    }

    private fun <V : UseCase.ResponseValue> notifyResponse(response: V, useCaseCallback: UseCase.UseCaseCallback<V>) {
        mUseCaseScheduler.notifyResponse(response, useCaseCallback)
    }

    private fun <V : UseCase.ResponseValue> notifyError(
            useCaseCallback: UseCase.UseCaseCallback<V>, t: Throwable) {
        mUseCaseScheduler.onError(useCaseCallback, t)
    }

    private class UiCallbackWrapper<V : UseCase.ResponseValue>(
    private val mCallback: UseCase.UseCaseCallback<V>,
    private val mUseCaseHandler: UseCaseHandler) : UseCase.UseCaseCallback<V> {

        override fun onSuccess(response: V) {
            mUseCaseHandler.notifyResponse(response, mCallback)
        }

        override fun onError(t: Throwable) {
            mUseCaseHandler.notifyError(mCallback, t)
        }
    }

    companion object {
        private var INSTANCE: UseCaseHandler? = null
        fun getInstance(): UseCaseHandler {
            if (INSTANCE == null) {
                INSTANCE = UseCaseHandler(UseCaseThreadPoolScheduler())
            }
            return INSTANCE!!
        }
    }
}

顾名思义，GetPosts, UseCase 负责获取用户的所有帖子。

class GetPosts(private val mDataSource: PostDataSource) :
UseCase<GetPosts.RequestValues, GetPosts.ResponseValue>() {

    protected override fun executeUseCase(requestValues: GetPosts.RequestValues?) {
        mDataSource.getPosts(
            requestValues?.userId ?: -1, 
            object : PostDataSource.LoadPostsCallback {
                override fun onPostsLoaded(posts: List<Post>) {
                    val responseValue = ResponseValue(posts)
                    useCaseCallback?.onSuccess(responseValue)
                }
                override fun onError(t: Throwable) {
                    useCaseCallback?.onError(Throwable("Data not found"))
                }
            }
        )
    }
    class RequestValues(val userId: Int) : UseCase.RequestValues
    class ResponseValue(val posts: List<Post>) : UseCase.ResponseValue
}

用例 UseCase 的目的是成为 ViewModel 和 Repository 之间的中介。

假设将来决定添加 “编辑帖子” 功能。所要做的就是添加一个新的 EditPost UseCase，它的所有代码将与其他 UseCase 完全分离和解耦。引入新功能，但无意中破坏了现有代码中的某些内容。创建一个单独的 UseCase 有助于极大地避免这种情况。

当然，无法 100% 消除这种可能性，但肯定可以将其最小化。这就是 Clean 架构与其他模式的区别：代码如此解耦，以至于可以将每一层视为黑匣子。

数据层

该层向外部类公开数据源 API：

interface PostDataSource {

    interface LoadPostsCallback {
        fun onPostsLoaded(posts: List<Post>)
        fun onError(t: Throwable)
    }

    interface SaveTaskCallback {
        fun onSaveSuccess()
        fun onError(t: Throwable)
    }

    fun getPosts(userId: Int, callback: LoadPostsCallback)
    fun savePost(post: Post)
}

PostDataRepository 实现 PostDataSource。它决定是从本地数据库还是远程服务器获取数据。

class PostDataRepository private constructor(
    private val localDataSource: PostDataSource,
    private val remoteDataSource: PostDataSource
): PostDataSource {

    companion object {
        private var INSTANCE: PostDataRepository? = null
        fun getInstance(localDataSource: PostDataSource, remoteDataSource: PostDataSource): PostDataRepository {
            if (INSTANCE == null) {
                INSTANCE = PostDataRepository(localDataSource, remoteDataSource)
            }
            return INSTANCE!!
        }
    }
    var isCacheDirty = false
    override fun getPosts(userId: Int, callback: PostDataSource.LoadPostsCallback) {
        if (isCacheDirty) {
            getPostsFromServer(userId, callback)
        } else {
            localDataSource.getPosts(userId, object : PostDataSource.LoadPostsCallback {
                override fun onPostsLoaded(posts: List<Post>) {
                    refreshCache()
                    callback.onPostsLoaded(posts)
                }
                override fun onError(t: Throwable) {
                    getPostsFromServer(userId, callback)
                }
            })
        }
    }
    override fun savePost(post: Post) {
        localDataSource.savePost(post)
        remoteDataSource.savePost(post)
    }
    private fun getPostsFromServer(userId: Int, callback: PostDataSource.LoadPostsCallback) {
        remoteDataSource.getPosts(userId, object : PostDataSource.LoadPostsCallback {
            override fun onPostsLoaded(posts: List<Post>) {
                refreshCache()
                refreshLocalDataSource(posts)
                callback.onPostsLoaded(posts)
            }
            override fun onError(t: Throwable) {
                callback.onError(t)
            }
        })
    }
    private fun refreshLocalDataSource(posts: List<Post>) {
        posts.forEach {
            localDataSource.savePost(it)
        }
    }
    private fun refreshCache() {
        isCacheDirty = false
    }
}

这个类有两个变量：localDataSource 和remoteDataSource。它们的类型是 PostDataSource，所以不用关心它们实际上是如何实现的。

如果想要调整远程数据源，所要做的就是更改 RemoteDataSource 中的实现。这样不必接触任何其他类。这就是解耦代码的优点。更改任何给定的类不应影响代码的其他部分。

另外还有一些额外的类：

interface UseCaseScheduler {

    fun execute(runnable: Runnable)

    fun <V : UseCase.ResponseValue> notifyResponse(response: V, useCaseCallback: UseCase.UseCaseCallback<V>)

    fun <V : UseCase.ResponseValue> onError(useCaseCallback: UseCase.UseCaseCallback<V>, t: Throwable)
}


class UseCaseThreadPoolScheduler : UseCaseScheduler {

    val POOL_SIZE = 2

    val MAX_POOL_SIZE = 4

    val TIMEOUT = 30

    private val mHandler = Handler()

    internal var mThreadPoolExecutor: ThreadPoolExecutor

    init {
        mThreadPoolExecutor = ThreadPoolExecutor(
            POOL_SIZE, MAX_POOL_SIZE, 
            TIMEOUT.toLong(),
            TimeUnit.SECONDS, 
            ArrayBlockingQueue(POOL_SIZE)
        )
    }

    override fun execute(runnable: Runnable) {
        mThreadPoolExecutor.execute(runnable)
    }

    override fun <V : UseCase.ResponseValue> notifyResponse(response: V, useCaseCallback: UseCase.UseCaseCallback<V>) {
        mHandler.post { useCaseCallback.onSuccess(response) }
    }

    override fun <V : UseCase.ResponseValue> onError(useCaseCallback: UseCase.UseCaseCallback<V>, t: Throwable) {
        mHandler.post { useCaseCallback.onError(t) }
    }

}

UseCaseThreadPoolScheduler 负责使用 ThreadPoolExecuter 异步执行任务。

class ViewModelFactory : ViewModelProvider.Factory {

    override fun <T : ViewModel> create(modelClass: Class<T>): T {
        if (modelClass == PostListViewModel::class.java) {
            return PostListViewModel(
                Injection.provideUseCaseHandler(), 
                Injection.provideGetPosts(), 
                Injection.provideSavePost()
            ) as T
        }
        throw IllegalArgumentException("unknown model class $modelClass")
    }

    companion object {
        private var INSTANCE: ViewModelFactory? = null
        fun getInstance(): ViewModelFactory {
            if (INSTANCE == null) {
                INSTANCE = ViewModelFactory()
            }
            return INSTANCE!!
        }
    }
}

ViewModelFactory 负责创建 ViewModel 构造函数中传递必要的参数。

依赖注入

再用一个例子来解释依赖注入。查看 PostDataRepository 类，它有两个依赖项：LocalDataSource 和 RemoteDataSource。使用 Injection 类向 PostDataRepository 类提供这些依赖项。

注入依赖有两个主要优点。

一是可以从一个中心位置控制对象的实例化，而不是将其分散到整个代码库。
另一个原因是，这将帮助我们为 PostDataRepository 编写单元测试，因为只需将 LocalDataSource 和 RemoteDataSource 的 Mock 版本传递给 PostDataRepository 构造函数而不是实际值。

object Injection {

    fun providePostDataRepository(): PostDataRepository {
        return PostDataRepository.getInstance(provideLocalDataSource(), provideRemoteDataSource())
    }

    fun provideViewModelFactory() = ViewModelFactory.getInstance()

    fun provideLocalDataSource(): PostDataSource = LocalDataSource.getInstance()

    fun provideRemoteDataSource(): PostDataSource = RemoteDataSource.getInstance()

    fun provideGetPosts() = GetPosts(providePostDataRepository())

    fun provideSavePost() = SavePost(providePostDataRepository())

    fun provideUseCaseHandler() = UseCaseHandler.getInstance()
}

强烈建议使用 Hilt，超出了本文范围，可以参考这里

MVVM 结合 Clean：牢固的组合

这个案例的目的是了解具有 Clean 架构的 MVVM，因此跳过了一些可以尝试进一步改进的内容：

使用 Coroutine 删除回调并使其更加整洁。
使用 Flow 来表示 UI。
使用 Hilt 注入依赖项。

这就是 Android 应用程序最好、最具可扩展性的架构之一！

Android

#Architecture

Vue+Node::VM 沙盒控制台工具上一篇

一文搞懂 CMake 下一篇