Android 协同程序和改进，处理错误的最佳方法

在阅读了本期和本媒体之后，我创建了我的解决方案，它包含在一个

基本服务中

，能够进行改装调用，并将结果和异常转发到“链”中：

API

@GET("...")
suspend fun fetchMyObject(): Response<List<MyObject>>

更多关于这种方法的信息

BaseViewModel

protected suspend fun <T : Any> safeCall(call: suspend () -> T): T? {
    try {
        return call()
    } catch (e: Throwable) {
        parseError(e)
    }
    return null
}

fun fetchMyObjectList() {
    viewModelScope.launch {
        safeCall(call = {
            repo.myObjectList()
            //update ui, etc..
        })
    }
}

我认为

ViewModel

（或

BaseViewModel

）应该是处理异常的层，因为在这一层中存在UI决策逻辑，例如，如果我们只想显示一个toast，忽略一种异常类型，调用另一个函数等等

你觉得怎么样

编辑：我已经创建了一个与此主题相关的

我认为ViewModel（或BaseViewModel）应该是图层 处理异常，因为在这一层中存在UI决策 例如，逻辑上，如果我们只想展示一个祝酒词，那么忽略一种 异常，调用另一个函数等

你觉得怎么样

当然，你是对的。即使逻辑在

存储库

/

服务

中，协同程序也应在

视图模型

上启动。这就是为什么谷歌已经创建了一个名为“repositoryScope”的特殊的

coroutineScope

。此外，协同程序在异常处理方面有一个很好的特性，称为

CoroutineExceptionHandler

。这就是事情变得更好的地方，因为您不必实现

try{}catch{}

块：

val coroutineExceptionHanlder = CoroutineExceptionHandler{_, throwable -> 
    throwable.printStackTrance()
    toastLiveData.value = showToastValueWhatever()
}

稍后在

视图模型中

coroutineScope.launch(Dispatchers.IO + coroutineExceptionHanlder){
      val data = serviceOrRepo.getData()
}

当然，您仍然可以使用

try/catch

块，而不使用

CoroutineExceptionHandler

，可以自由选择

请注意，在进行改装的情况下，您不需要

Dispatchers.IO

调度程序，因为改装为您提供了这一功能（自改装2.6.0以来）

无论如何，我不能说这篇文章不好，但它不是最好的解决方案。如果您想遵循文章指南，您可能需要查看

编辑： 你需要知道的是，合作项目并不安全。我的意思是，它们可能会导致内存泄漏，尤其是在Android的整个生命周期中。当

活动

/

片段

不再存在时，您需要一种取消协同路由的方法。由于

ViewModel

具有

onCleared

（在

活动

/

片段

被销毁时调用），这意味着协同程序应该在其中一个中启动。也许这就是您应该在

ViewModel

中启动协同程序的主要原因。请注意，使用

viewModelScope

无需

cancel

作业

onCleared

一个简单的例子：

viewModelScope.launch(Dispatchers.IO) {
   val data = getDataSlowly()
   withContext(Dispatchers.MAIN) {
      showData();
   }
} 

或者不使用

viewModelScope

：

val job = Job()
val coroutineScope = CoroutineContext(Dispatchers.MAIN + job)

fun fetchData() {
   coroutineScope.launch() {
   val data = getDataSlowly()
       withContext(Dispatchers.MAIN) {
          showData();
       }
   }
}

//later in the viewmodel:

override fun onCleared(){
  super.onCleared()
  job.cancel() //to prevent leaks
}

---

否则，您的

服务

/

存储库

将泄漏。在这种情况下，另一个注意事项是而不是。

我建议在存储库中处理异常，并以密封类对象的形式向viewmodel返回单个响应。将其保存在存储库中会使存储库成为真相和代码的唯一来源

---

清晰易读。

作为@coroutineDispatcher卓越答案的补充，我建议捕获异常并检查它是HttpException、UnknownHostException还是SocketException，以便向用户提供有关异常的更多反馈。比如说

if (throwable is SocketException) {
     //very bad internet 
     return
}

if (throwable is HttpException) {
     // parse error body message from
     //throwable.response().errorBody()
     return
 }

if (throwable is UnknownHostException) {
     // probably no internet or your base url is wrong
     return
 }
 ShowSomethingWentWrong()

---

以上所有代码都包含在

coroutineexceptionhandler

中，谢谢您的帖子。实际上，正如您在我的示例代码中所看到的，我正在使用

viewModelScope

来进行repo调用，它将使用

withContext（Dispatchers.IO）

来调用改型。缺少的唯一一段代码是启动调用的活动。在这种情况下，我从viewModel中公开了一个

suspend fun

，将在

LifeCycleScope

中调用。我猜这个选择是正确的，考虑你的答案吧？当你说改型2.6.0对我来说使用了

Dispatchers.IO

时，这意味着我的repo中的

withContext（Dispatchers.IO）

可以被删除？该活动将只保留viewmodel的引用，并说：

myViewModel.fetchMyObjectList（）

不是作为挂起，而是作为一种方法。然后在

fetchMyObjectList（）中

只需

viewModelScope.launch

。是的，如果您有Reformation 2.6+，并且在您的协同程序中只有Reformation调用，那么不需要

withContext（Dispatchers.IO）

为什么不应该在

生命周期范围内？我想这可能取决于用例，但如果我转移到其他活动（进入bg no时可能会有问题？），我想取消该网络呼叫。把它放在
lifecycleScope
里对我来说不行吗？（我仍在学习如何使用协同程序，也许我误解了一些概念^^）使用
lifecycleScope
也可以，但是
视图必须不知道您的调用。视图仅用于渲染viewmodel提供的内容。因此，您打破了坚实原则的第一部分，Syou可以用
CoroutineExceptionHandler
替换try/catch块，它仍然是一样的，因此您建议将
返回when（result）
从
BaseService
移动到我的
存储库中（这将使
BaseService
仅返回
result
）并在
为result.Success->{…}
时处理数据，并将错误转发到
为result.error->throw result.exception
。我做对了吗？我要编辑我的代码；）
val coroutineExceptionHanlder = CoroutineExceptionHandler{_, throwable -> 
    throwable.printStackTrance()
    toastLiveData.value = showToastValueWhatever()
}

coroutineScope.launch(Dispatchers.IO + coroutineExceptionHanlder){
      val data = serviceOrRepo.getData()
}

viewModelScope.launch(Dispatchers.IO) {
   val data = getDataSlowly()
   withContext(Dispatchers.MAIN) {
      showData();
   }
} 

val job = Job()
val coroutineScope = CoroutineContext(Dispatchers.MAIN + job)

fun fetchData() {
   coroutineScope.launch() {
   val data = getDataSlowly()
       withContext(Dispatchers.MAIN) {
          showData();
       }
   }
}

//later in the viewmodel:

override fun onCleared(){
  super.onCleared()
  job.cancel() //to prevent leaks
}

if (throwable is SocketException) {
     //very bad internet 
     return
}

if (throwable is HttpException) {
     // parse error body message from
     //throwable.response().errorBody()
     return
 }

if (throwable is UnknownHostException) {
     // probably no internet or your base url is wrong
     return
 }
 ShowSomethingWentWrong()