前言
在 App 中，对于网络请求状态一般性的就分为加载中、请求错误、请求成功、请求成功但数据为 null。为了用户体验，不同的状态需要对用户展示不同的界面，例如网络异常的提醒，点击重新请求等。
之前项目一直都是以 Retrofit+RxJava+OkHttp 为网络请求框架，RxJava 已经很好的封装了不同的请求状态，onSubscribe、onNext、onError 等，只需要在不同的回调中做出相应的动作就 ok 了。
RxJava 很好用，但随着新技术的出现，RxJava 的可替代性也就越高。Kotlin 的协程就是这么一个存在。
本文是以 Jetpack 架构为基础，协程+Retrofit+Okhttp 为网络请求框架，对不同的请求状态（loading，error，empty 等）做了封装，让开发者不用再去关心哪里需要 loading，哪里需要展示 error 提示。
同时，在封装的过程中，Jetpack 和协程的使用也存在着几个坑，本文也将一一描述。
协程的基本使用
API：https://www.wanandroid.com/project/tree/json 来自鸿洋大大的 wanandroid
如果需要使用协程，则添加依赖
dependencies { implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.9'}
复制代码
在 Retrofit2.6.0 前，我们使用协程，api 请求后返回的数据可以用 Call<Data>或者 Defeerd 包裹处理，2.6 后，可以直接返回数据，只不过需要加上 suspend 的修饰，如下：
interface ProjectApi {
@GET("project/tree/json") suspend fun loadProjectTree(): BaseResp<List<ProjectTree>>}
复制代码
因为使用的是 Jetpack 架构，所以将整个网络请求主要分为 UI、ViewModel、Repository 三层，以 LiveData 为媒介进行通信。
首先是 Repository 层进行网络请求，
class ProjectRepo{ private lateinit var mService: ProjectApi
init { mService = RetrofitManager.initRetrofit().getService(ProjectApi::class.java) }
suspend fun loadProjectTree(): List<ProjectTree> { return mService.loadProjectTree() } }
复制代码
利用 Retrofit 和 OkHttp 创建了一个 apiService，内部细节在这里就先不展开，接着直接调用 loadProjectTree()进行网络请求，将数据返回。loadProjectTree()用 suspend 关键字进行标记，Kotlin 利用此关键字强制从协程内调用函数。
接着 ViewModel 层，
class ProjectViewModel : ViewModel(){ //LiveData val mProjectTreeLiveData = MutableLiveData<List<ProjectTree>>() fun loadProjectTree() { viewModelScope.launch(Dispatchers.IO) { val data = mRepo.loadProjectTree() mProjectTreeLiveData.postValue(data) } }}
复制代码
创建类 ProjectViewModel 并继承 ViewModel，内部新建一个 LiveData 做 UI 通信使用，利用viewModelScope.launch(Dispatchers.IO) 创建一个新的协程，然后在 I/O 线程上执行网络请求，请求的数据利用 LiveData 通知给 UI。
这里提到了viewModelScope.launch(Dispatchers.IO)，viewModelScope是一个协程的作用域，ViewModel KTX 扩展中已经将此作用域封装好，直接使用就可以。Dispatchers.IO 表示此协程在 I/O 线程上执行，而 launch 则是创建一个新的协程。
最后是 UI 层，
class ProjectFragment : Fragment {
override fun initData() { //请求数据，调用loadProjectTree mViewModel?.loadProjectTree() mViewModel?.mProjectTreeLiveData?.observe(this, Observer { //更新UI }) }
复制代码
UI 层开始调用 ViewModel 的请求方法执行网络请求，LiveData 注册一个观察者，观察数据变化，并且更新 UI。
到这里，网络请求的逻辑基本上通顺了。
在一切环境正常的情况下，上面的请求是可以的，但是 app 还存在网络不畅，异常，数据为 null 的情况，上述就不在满足要求了，接下来就开始对数据异常的情况进行处理。
网络请求异常处理
对于协程异常的处理，Android 开发者的官网上也给出了答案（https://developer.android.google.cn/kotlin/coroutines?hl=zh-cn ） ，直接对网络请求进行一个try-catch处理，发生异常了，直接在 catch 中做出相应动作就 ok 了，我们就来看看具体实现。
class ProjectViewModel : ViewModel(){ //LiveData val mProjectTreeLiveData = MutableLiveData<List<ProjectTree>>() fun loadProjectTree() { viewModelScope.launch(Dispatchers.IO) { try { val data = mRepo.loadProjectTree() mProjectTreeLiveData.postValue(data) } catch (e: Exception) { //异常 error(e) } finally { } } }}
复制代码
还是在 ViewModel 层，对 mRepo.loadProjectTree()的请求加上了 try-catch 块，当发生异常时根据 Exception 类型对用户做出提示。
到这里，异常的来源已经找到了，接着就需要将异常显示在 UI 层来提醒用户。我们都知道 mProjectTreeLiveData 利用 PostValue 将数据分发给了 UI，如法炮制，也就可以利用 LiveData 将异常也分发给 UI。
说干就干。
网络请求状态封装
1、 [Error 状态]
依旧在 ViewModel 层，我们新添加一个针对异常的 LiveData：errorLiveData
class ProjectViewModel : ViewModel(){ //异常LiveData val errorLiveData = MutableLiveData<Throwable>() //LiveData val mProjectTreeLiveData = MutableLiveData<List<ProjectTree>>() fun loadProjectTree() { viewModelScope.launch(Dispatchers.IO) { try { val data = mRepo.loadProjectTree() mProjectTreeLiveData.postValue(data) } catch (e: Exception) { //异常 error(e) errorLiveData.postValue(e) } finally { } } }}
复制代码
在 UI 层，利用 errorLiveData 注册一个观察者，如果有异常通知，则显示异常的 UI（UI 层代码省略）。这样确实可以实现我们一开始要的功能：请求成功则显示成功界面，失败显示异常界面。但是有一个问题，就是不够优雅，如果有多个 ViewModel，多个 UI，那就要每个页面都要写 errorLiveData，很冗余。
那我们可以将公共方法抽离出来，新建一个 BaseViewModel 类,
open class BaseViewModel : ViewModel() { val errorLiveData = MutableLiveData<Throwable>()
fun launch( block: suspend () -> Unit, error: suspend (Throwable) -> Unit, complete: suspend () -> Unit ) { viewModelScope.launch(Dispatchers.IO) { try { block() } catch (e: Exception) { error(e) } finally { complete() } } }
}
复制代码
除了定义 errorLiveData 外，还将新建协程的操作放到其中，开发者只需要将每个 ViewModel 继承 BaseViewModel，重写 launch（）即可，那么上面的案例中的 ViewModel 就修改成下面这种，
class ProjectViewModel : BaseViewModel(){ //LiveData val mProjectTreeLiveData = MutableLiveData<List<ProjectTree>>() fun loadProjectTree() { launch( { val state = mRepo.loadProjectTree() mProjectTreeLiveData.postValue(state.data) }, { errorLiveData.postValue(it) }, { loadingLiveData.postValue(false) } ) }}
复制代码
同样的，UI 层也可以新建一个 BaseFragment 抽象类，在 onViewCreated 中利用 errorLiveData 注册观察者，收到异常通知，则进行相应的动作。
abstract class BaseFragment<T : ViewDataBinding, VM : BaseViewModel> : Fragment(){
override fun onViewCreated(view: View, savedInstanceState: Bundle?) { super.onViewCreated(view, savedInstanceState) mViewModel = getViewModel() mViewModel?.errorLiveData?.observe(viewLifecycleOwner, Observer { Log.d(TAG, "onViewCreated: error ") showError() throwableHandler(it) }) }}
复制代码
每个子 Fragment 只需要继承 BaseFragment 即可，具体的异常监听就不用开发者管理。
2、 [Loading 状态]
除了异常状态外，请求必不可少的就是 Loading，这里 Loading 分为两种，一种是整个页面替换为 Loading，例如 Recyclerview 列表时，就可以直接整个页面先 Loading，而后显示数据；还有一种是数据界面不替换，只是个 Loading Dialog 显示在上层，例如点击登录时，需要一个 loading。
Loading 和异常处理的思路一致，可以在 BaseViewModel 中添加一个 LoadingLiveData，数据类型为 Boolean，在每个请求一开始LoadingLiveData.postValue(true)，结束请求或者请求异常时，就LoadingLiveData.postValue(false)。UI 层 BaseFragment 中，则可以监听 LoadingLiveData 发出的是 true 还是 false，以便对 Loading 的显示和隐藏进行控制。
ViewModel 层：
open class BaseViewModel : ViewModel() { //加载中 val loadingLiveData = SingleLiveData<Boolean>() //异常 val errorLiveData = SingleLiveData<Throwable>()
fun launch( block: suspend () -> Unit, error: suspend (Throwable) -> Unit, complete: suspend () -> Unit ) { loadingLiveData.postValue(true) viewModelScope.launch(Dispatchers.IO) { try { block() } catch (e: Exception) { Log.d(TAG, "launch: error ") error(e) } finally { complete() } } }}
复制代码
在 BaseViewModel 中 launch 一开始就通知 Loading 显示，在try-catch-finally代码块的finally中将请求结束的通知分发出去。
UI 层：
abstract class BaseFragment<T : ViewDataBinding, VM : BaseViewModel> : Fragment(){
override fun onViewCreated(view: View, savedInstanceState: Bundle?) { super.onViewCreated(view, savedInstanceState) mViewModel = getViewModel() //Loading 显示隐藏的监听 mViewModel?.loadingLiveData?.observe(viewLifecycleOwner, Observer { if (it) { //show loading showLoading() } else { dismissLoading() } }) //请求异常的监听 mViewModel?.errorLiveData?.observe(viewLifecycleOwner, Observer { Log.d(TAG, "onViewCreated: error ") showError() throwableHandler(it) }) }}
复制代码
注册一个 loading 的观察者，当通知为 true 时，显示 loading，false 则隐藏。
3、 [Empty 状态]
数据为空的状态发生在请求成功后，对于这种情况，可以直接在 UI 层中，请求成功的监听中对数据是否为 null 进行判断。
到这里，网络请求的基本封装已经完成，但是在运行测试的过程中，存在几个问题需要去解决，例如网络不通的情况下 try-catch 却不会抛出异常。接下来就开始进行二次封装。
暴露问题二次封装
问题一：网络请求异常，try-catch 却不会将异常抛出
因为业务场景比较复杂，只依赖 try-catch 来获取异常，明显也会有所遗漏，那这种情况下我们可以直接以服务器返回的 code，作为请求状态的依据。以上面 Wanandroid 的 api 为例，当 errorCode=0 时，则表示请求成功，其他的值都表示失败，那这就好办了。
我们新建一个密封类 ResState，存放 Success 和 Error 状态，
sealed class ResState<out T : Any> { data class Success<out T : Any>(val data: T) : ResState<T>() data class Error(val exception: Exception) : ResState<Nothing>()}
复制代码
对 Repository 层请求返回的数据进行 code 判断处理，新建一个 BaseRepository 类，
open class BaseRepository() {
suspend fun <T : Any> executeResp( resp: BaseResp<T>, successBlock: (suspend CoroutineScope.() -> Unit)? = null, errorBlock: (suspend CoroutineScope.() -> Unit)? = null ): ResState<T> { return coroutineScope { if (resp.errorCode == 0) { successBlock?.let { it() } ResState.Success(resp.data) } else { Log.d(TAG, "executeResp: error") errorBlock?.let { it() } ResState.Error(IOException(resp.errorMsg)) } } }
}
复制代码
当errorCode == 0时，将 ResState 置为Success并将数据返回，errorCode !=0时，则将状态置为Error并将 Exception 返回。而子 Repository 则只需要继承 BaseRepository 即可，
class ProjectRepo : BaseRepository() {
suspend fun loadProjectTree(): ResState<List<ProjectTree>> { return executeResp(mService.loadProjectTree()) }
复制代码
修改后返回值用 ResState<>包裹，并直接将请求的结果传给 executeResp（）方法，而 ViewModel 中也做出相应的修改，
class ProjectViewModel : BaseViewModel() { val mProjectTreeLiveData = MutableLiveData<List<ProjectTree>>()
fun loadProjectTree() { launch( { val state = mRepo.loadProjectTree() //添加ResState判断 if (state is ResState.Success) { mProjectTreeLiveData.postValue(state.data) } else if (state is ResState.Error) { Log.d(TAG, "loadProjectTree: ResState.Error") errorLiveData.postValue(state.exception) } }, { errorLiveData.postValue(it) }, { loadingLiveData.postValue(false) } ) }}
复制代码
ViewModel 层新增了一个 ResState 判断，通过请求的返回值 ResState，如果是 ResState.Success 则将数据通知给 UI，如果是 ResState.Error，则将异常通知给 UI。
以服务器返回的 code 值进行判断，无疑是最准确的。
问题二：errorLiveData 注册观察者一次后，不管请求失败还是成功，它还是会收到通知。
这是 MutableLiveData 的一个特性，只要当注册的观察者处于前台时，都会收到通知。那这个特性又影响了什么呢？我在 errorLiveData 的监听中，对不同的异常进行了 Toast 的弹出提醒，如果每次进入一个页面，虽然请求成功了，但是因为 errorLiveData 还是能接收到通知，就会弹出一个 Toast 提醒框。现象如下：
那我们针对 MutableLiveData 将其修改为单事件响应的 liveData，只有一个接收者能接收到信息，可以避免不必要的业务的场景中的事件消费通知。
class SingleLiveData<T> : MutableLiveData<T>() {
private val mPending = AtomicBoolean(false)
@MainThread override fun observe(owner: LifecycleOwner, observer: Observer<in T>) {
if (hasActiveObservers()) { Log.w(TAG, "多个观察者存在的时候，只会有一个被通知到数据更新") }
super.observe(owner, Observer { t -> if (mPending.compareAndSet(true, false)) { observer.onChanged(t) } })
}
override fun setValue(value: T?) { mPending.set(true) super.setValue(value) }
@MainThread fun call() { value = null }
companion object { private const val TAG = "SingleLiveData" }}
复制代码
将 BaseViewModel 中的 MutableLiveData 替换为 SingleLiveData 就可以了。
最后
至此，协程+Retrofit 网络请求状态封装也就完成了，对于 Error、Empty 等 view 的切换以及点击重新请求等操作，这里就不一一展示了，可以移步到github里查看。最后我们来看一下请求效果。
源码:组件化+Jetpack+kotlin+mvvm
2021.5.20 更新：
对于网络封装已经做出升级，更加简便快捷，具体内容请查看 ：
【Jetpack篇】协程+Retrofit网络请求状态封装实战（2）
评论