MVI 架构封装之网络请求

金戈鐡馬

已于 2023-02-26 12:32:59 修改

阅读量443

点赞数 1

分类专栏： Android 文章标签： android MVI MVVM 网络请求封装架构 Powered by 金山文档

于 2023-02-26 12:27:55 首次发布

本文链接：https://blog.csdn.net/qq_39312146/article/details/129220932

版权

Android 专栏收录该内容

223 篇文章 53 订阅

订阅专栏

网络请求可以说是Android开发中最常见的需求之一，基本上每个页面都需要发起几个网络请求。因此大家通常都会对网络请求进行一定的封装，解决模板代码过多,重复代码，异常捕获等一些问题。

本文主要包括以下内容：

MVVM架构下的网络请求封装与问题

MVI架构下封装网络请求

MVI架构与Flow结合实现网络请求

MVVM架构下的网络请求封装与问题

相信大家都看过不少MVVM架构下的网络请求封装，一般是这样写的。

# MainViewModel
class MainViewModel {
    private val _userLiveData = MutableStateLiveData<User?>()
    val userLiveData : StateLiveData<User?> = _userLiveData
    fun login(username: String, password: String) {
        viewModelScope.launch {
            _userLiveData.value = repository.login(username, password)
        }
    }
}

class MainActivity : AppCompatActivity() {
    fun initViewModel(){
    // 请求网络
    mViewModel.login("username", "password")
    // 注册监听
    mViewModel.userLiveData.observeState(this) {
            onLoading {
        showLoading()
            }
            onSuccess {data ->
        mBinding.tvContent.text = data.toString()
            }
            onError {
                dismissLoading()
            }
    }
    }
}

如上所示，就是最常见的MVVM架构下网络请求封装，主要思路如是：

添加一个StateLiveData，一个LiveData支持多种状态，例如加载中，加载成功，加载失败等

在页面中监听StateLiveData，在页面中处理onLoading，onSuccess，onError等逻辑

这种封装的本质其实就是将请求的回调逻辑处理迁移到View层了，这其实并不是我们想要的，我们的理想状况应该是逻辑尽量放在ViewModel中，View层只需要监听ViewModel层并更新UI。

既然这种封装其实违背了不在View层写逻辑的原则，那么为什么还有那么多人用呢？

本质上是因为ViewModel层与View层的通信成本比较高。

想象一下，如果我们不使用StateLiveData，针对每个请求就需要新建一个LiveData来表示请求状态，如果成功或失败后需要弹Toast或者Dialog，或者页面中有多个请求，就需要定义更多的LiveData，同时为了保证对外暴露的LiveData不可变，每个状态都需要定义两遍LiveData。

这就是为什么这种封装其实违背了不在View层写逻辑但仍然流行的原因，因为在MVVM架构中每处理一种状态，就需要添加两个LiveData，成本较高，大多数人并不愿意支付这个成本。

而MVI架构正解决了这个问题。

MVI架构下封装网络请求

之前已经介绍过了MVI架构，MVI架构使用方面我们就不再多说，我们直接来看下MVI架构下怎么发起一个简单网络请求。

简单的网络请求

class NetworkViewModel : ViewModel() {
    /**
     * 页面请求，通常包括刷新页面loading状态等
     */
    private fun pageRequest() {
        viewModelScope.rxLaunch<String> {
            onRequest = {
                _viewStates.setState { copy(pageStatus = PageStatus.Loading) }
                delay(2000)
                "页面请求成功"
            }
            onSuccess = {
                _viewStates.setState { copy(content = it, pageStatus = PageStatus.Success) }
                _viewEvents.setEvent(NetworkViewEvent.ShowToast("请求成功"))
            }
            onError = {
                _viewStates.setState { copy(pageStatus = PageStatus.Error(it)) }
            }
        }
    }
}

# Activity层
class MainActivity : AppCompatActivity() {
    private fun initViewModel() {
        viewModel.viewStates.let { state ->
            //监听网络请求状态
            state.observeState(this, NetworkViewState::pageStatus) {
                when (it) {
                    is PageStatus.Success -> state_layout.showContent()
                    is PageStatus.Loading -> state_layout.showLoading()
                    is PageStatus.Error -> state_layout.showError()
                }
            }
            //监听页面数据
            state.observeState(this, NetworkViewState::content) {
                tv_content.text = it
            }
        }
        //监听一次性事件，如Toast,ShowDialog等   
        viewModel.viewEvents.observe(this) {
            when (it) {
                is NetworkViewEvent.ShowToast -> toast(it.message)
                is NetworkViewEvent.ShowLoadingDialog -> showLoadingDialog()
                is NetworkViewEvent.DismissLoadingDialog -> dismissLoadingDialog()
            }
        }
    }
}

如上，代码很简单：

页面的所有状态都存储在NetworkViewState中，后面如果需要添加状态不需要添加LiveData，添加属性即可，NetworkViewEvent中存储了所有一次事件，同理

ViewModel中发起网络请求并监听网络请求回调，其中viewModelScope.rxLaunch是我们自定义的扩展方法，后面会再介绍

ViewModel中在请求的onRequest，onSuccess，onError时会通过_viewStates更新页面，通过_viewEvents添加一次性事件，如Toast

View层只需要监听ViewState与ViewEvent并更新UI，页面的逻辑全都在ViewModel中写

通过使用MVI架构，所有的逻辑都在ViewModel中处理，同时添加新状态时不需要添加LiveData，降低了View与ViewModel的通信成本，解决了MVVM架构下的一些问题。

局部网络请求

我们页面中通常会有一些局部网络请求，例如点赞，收藏等，这些网络请求不需要刷新整个页面，只需要处理单个View的状态或者弹出Toast。下面我们来看下MVI架构下是如何实现的：

 /**
     * 页面局部请求，例如点赞收藏等，通常需要弹dialog或toast
     */
    private fun partRequest() {
        viewModelScope.rxLaunch<String> {
            onRequest = {
                _viewEvents.setEvent(NetworkViewEvent.ShowLoadingDialog)
                delay(2000)
                "点赞成功"
            }
            onSuccess = {
                _viewEvents.setEvent(NetworkViewEvent.DismissLoadingDialog)
                _viewEvents.setEvent(NetworkViewEvent.ShowToast(it))
                _viewStates.setState { copy(content = it) }
            }
            onError = {
                _viewEvents.setEvent(NetworkViewEvent.DismissLoadingDialog)
            }
        }
    }

如上，针对局部网络请求，我们也是通过_viewStates与_viewEvents更新UI，并不需要添加额外的LiveData，使用起来比较方便。

多数据源请求

页面中通常也会有一些多数据源的请求，我们可以利用协程的async操作符处理。

/**
     * 多数据源请求
     */
    private fun multiSourceRequest() {
        viewModelScope.rxLaunch<String> {
            onRequest = {
                _viewEvents.setEvent(NetworkViewEvent.ShowLoadingDialog)
                coroutineScope {
                    val source1 = async { source1() }
                    val source2 = async { source2() }
                    val result = source1.await() + "," + source2.await()
                    result
                }
            }
            onSuccess = {
                _viewEvents.setEvent(NetworkViewEvent.DismissLoadingDialog)
                _viewEvents.setEvent(NetworkViewEvent.ShowToast(it))
                _viewStates.setState { copy(content = it) }
            }
            onError = {
                _viewEvents.setEvent(NetworkViewEvent.DismissLoadingDialog)
            }
        }
    }

异常处理

我们的APP中通常需要一些通用的异常处理，我们可以封装在rxLaunch扩展方法中。

  class CoroutineScopeHelper<T>(private val coroutineScope: CoroutineScope) {
    fun rxLaunch(init: LaunchBuilder<T>.() -> Unit): Job {
        val result = LaunchBuilder<T>().apply(init)
        val handler = NetworkExceptionHandler {
            result.onError?.invoke(it)
        }
        return coroutineScope.launch(handler) {
            val res: T = result.onRequest()
            result.onSuccess?.invoke(res)
        }
    }
}

如上：

rxLaunch就是我们定义的扩展方法，本质就是将协程转化为类RxJava的回调

通用的异常处理可写在自定义的NetworkExceptionHandler中，如果请求错误则会自动处理

处理后的异常将传递到onError中，供我们进一步处理

MVI架构与Flow结合实现网络请求

我们上面通过自定义扩展函数实现了rxLaunch，其实是将协程转化为类RXJava的写法，但其实kotin协程已经有了自己的RXJava : Flow。我们完全可以利用Flow来实现同样的功能，不需要自己自定义。

简单的网络请求

     /**
     * 页面请求，通常包括刷新页面loading状态等
     */
    private fun pageRequest() {
        viewModelScope.launch {
            flow {
                delay(2000)
                emit("页面请求成功")
            }.onStart {
                _viewStates.setState { copy(pageStatus = PageStatus.Loading) }
            }.onEach {
                _viewStates.setState { copy(content = it, pageStatus = PageStatus.Success) }
                _viewEvents.setEvent(NetworkViewEvent.ShowToast(it))
            }.commonCatch {
                _viewStates.setState { copy(pageStatus = PageStatus.Error(it)) }
            }.collect()
        }
    }

在flow中发起网络请求并将结果通过emit回调

onStart是请求的开始，这里触发Activity中的showLoading

在onEach中获取flow中emit的结果，即成功回调，在这里更新请求状态与页面数据

在commonCatch中捕获异常

局部的网络请求与这里类似，并且不需要添加额外的LiveData，这里就不缀述了

多数据源网络请求

Flow中提供了多个操作符，可以将多个Flow的结果组合起来。

    /**
     * 多数据源请求
     */
    private fun multiSourceRequest() {
        viewModelScope.launch {
            val flow1 = flow {
                delay(1000)
                emit("数据源1")
            }
            val flow2 = flow {
                delay(2000)
                emit("数据源2")
            }
            flow1.zip(flow2) { a, b ->
                "$a,$b"
            }.onStart {
                _viewEvents.setEvent(NetworkViewEvent.ShowLoadingDialog)
            }.onEach {
                _viewEvents.setEvent(NetworkViewEvent.DismissLoadingDialog)
                _viewEvents.setEvent(NetworkViewEvent.ShowToast(it))
                _viewStates.setState { copy(content = it) }
            }.commonCatch {
                _viewEvents.setEvent(NetworkViewEvent.DismissLoadingDialog)
            }.collect()
        }
    }

如上所示，其实是对Flow.catch的一个封装，读者可以根据自己的需求封装处理。

关于Repository

可以看到，我上面都没有使用到Repository，都是直接在ViewModel层中处理。平常在项目开发中也可以发现，一般的页面并没有写Repository的需要，直接在ViewModel中处理即可。

但如果数据获取比较复杂，比如同时从网络与本地数据获取，或者需要复用网络请求等时，也可以添加一个Repository。我们可以通过Repository获取数据后，再通过_viewState更新页面状态，如下所示：

private fun fetchNews() {
        viewModelScope.launch {
            flow {
                emit(repository.getMockApiResponse())
            }.onStart {
                _viewStates.setState { copy(fetchStatus = FetchStatus.Fetching) }
            }.onEach {
                _viewStates.setState { copy(fetchStatus = FetchStatus.Fetched, newsList = it.data)}
            }.commonCatch {
                _viewStates.setState { copy(fetchStatus = FetchStatus.Fetched) }
            }.collect()
        }
    }