Android:老版本Retrofit实现对kotlin协程的支持，封装简单的并发请求

浅浅的花香味﹌ 2022-09-09 02:26 180阅读 0赞

**Retrofit2.6**开始增加了对Kotlin协程的支持，可以通过suspend函数进行异步调用。  
但是有很多项目使用的Reftrofit版本较老，那怎么实现对kotlin协程的支持呢？下面提供一下实现方案。  
首先创建通用的Retrofit api。

data class User(val id: String, val name: String, val url: String)
    
    val gitApi by lazy { 
        val retrofit = Retrofit.Builder()
            .client(OkHttpClient.Builder().addInterceptor { 
                it.proceed(it.request()).apply { 
                    log("request : ${ code()}")
                }
            }.build())
            .baseUrl("https://api.github.com")
            .addConverterFactory(GsonConverterFactory.create())
            .build()
        retrofit.create(GitHupApi::class.java)
    }
    
    interface GitHupApi { 
        @GET("users/{login}")
        fun getUserCallBack(@Path("login") login: String): Call<User>
    }

### 实现await。 ###

suspend fun <T> Call<T>.wait(): T { 
        return suspendCancellableCoroutine {  cancellationContinuation ->
            cancellationContinuation.invokeOnCancellation { 
                //retrofit取消
                cancel()
            }
            //网络请求
            enqueue(object : Callback<T> { 
                override fun onResponse(call: Call<T>, response: Response<T>) { 
                    if (response.isSuccessful) { 
                        val body = response.body()
                        if (body == null) { 
                            cancellationContinuation.resumeWithException(HttpException(response))
                        } else { 
                            cancellationContinuation.resume(body)
                        }
                    } else { 
                        cancellationContinuation.resumeWithException(HttpException(response))
                    }
                }
    
                override fun onFailure(call: Call<T>, t: Throwable) { 
                    cancellationContinuation.resumeWithException(t)
                }
    
            })
    
        }
    }

**简单使用**：

val coroutineExceptionHandler = CoroutineExceptionHandler {  coroutineContext, throwable ->
                throwable.printStackTrace()
            }
            lifecycleScope.launch(coroutineExceptionHandler) { 
                val user = gitHubApi.getUserCallBack("zhangnangua").wait()
                log(user)
            }

### 如果是Retrofit+Rxjava的话，await可以这么实现。 ###

因为和rxjava配合使用的话，返回的就是Observable了，所以需要变一下。

data class ResultData<T>(
            val isSuccessful: Boolean,
            val result: T? = null,
            val errorCode: Int = 0,
            val errorText: String? = ""
    )
    suspend fun <T> Observable<T>.await(): ResultData<T> = suspendCancellableCoroutine {  cancellableContinuation ->
    
        var disposable: Disposable? = null
    
        subscribeOn(Schedulers.io())
                .doOnSubscribe { 
                    disposable = it
                }
                .subscribe({ 
                           result->
                    cancellableContinuation.resume(ResultData(isSuccessful = true, result = result))
                },{ 
                    throwable->
                    cancellableContinuation.resume(ResultData(isSuccessful = true, errorText = throwable.message))
                })
    
    
        cancellableContinuation.invokeOnCancellation { 
            disposable?.dispose()
        }
    }

可以看到使用了一个bean，包装了一下没有返回异常，因为rxjava会将产生的异常全部走onError回调，而我们包装一下全部走resume，那么理论上来说将不再产生异常。则调用处可以直接使用bean，将会更方便一点。  
**简单使用**：

Observable<JsonObject> obtainTest(@Field("params") String param)
    
    lifecycleScope.launch { 
        val resultData = ApiCall.obtainTest().await()
            if (resultData .isSuccessful){ 
                val result = resultData.result
            }else{ 
                val errorText = resultData.errorText
            }
    }

### 使用await+kotlin协程封装一个简单的并发请求处理方法。 ###

/** * 并发请求处理 * @param requests 传入所有的请求 * @param dataDealBlock 对网络请求回来的结果进行处理，异步线程，禁止操作UI * @param finallyBlock dataDealBlock处理完成后的返回值，在主线程。 */
    inline fun <T, R> CoroutineScope.concurrentRequest(@NonNull requests: List<Observable<T>?>, crossinline dataDealBlock: (List<ResultData<out T>?>) -> R, crossinline finallyBlock: (R?) -> Unit) { 
        //网络请求
        val deferredList = requests.map {  observable ->
            async { 
                observable?.await()
            }
        }.toList()
    
        //全局异常捕获
        val coroutineExceptionHandler = CoroutineExceptionHandler {  _, throwable ->
            throwable.printStackTrace()
        }
    
        launch(Dispatchers.Main.immediate + coroutineExceptionHandler) { 
            //获取网络请求结果 awaitAll可以相应取消
             val resultList = deferredList.awaitAll()
    
            //执行结果计算 默认线程池执行
            val finallyResult = withContext(Dispatchers.Default) { 
                dataDealBlock(resultList)
            }
    
            //最终结果，主线程
            if (isActive) { 
                finallyBlock(finallyResult)
            } else { 
                finallyBlock(null)
            }
        }
    
    }

**简单使用**：

lifecycleScope.concurrentRequest(
                listOf(ApiCall.obtainTest(), ApiCall.obtainTest(), ApiCall.obtainTest()),
                { 
                    // TODO: 2021/8/29 请求结果处理，异步线程
    
                },
                { 
                    // TODO: 2021/8/29 上一步处理回来的结果，在主线程 
    
                }
        )