Kotlin協程 ----- suspendCoroutine和suspendCancellableCoroutine的使用
阿新 • • 發佈：2022-05-30
簡介
- suspendCoroutine 的使用
- suspendCancellableCoroutine的使用
- Retrofit是如何支援協程的
suspendCoroutine 的使用
這裡我們將使用suspendCoroutine將單一方法的介面方法改造成具有返回值的方法
單一方法的回撥
宣告一個單一方法的介面
/**
* @author : zhangqi
* @time : 6/22/21
* desc : 單一方法介面
*/
interface SingleMethodCallback {
fun onCallBack(value: String)
}
接著模擬一個耗時的操作，當操作完畢我們把結果回撥給實現類
/**
* 模擬一個耗時操作
*/
private fun runTask(callback: SingleMethodCallback) {
thread {
Thread.sleep(1000)
callback.onCallBack("result")
}
}
最後我們呼叫runTask方法，傳入SingleMethodCallback的實現
private fun runTaskDefault() {
runTask(object : SingleMethodCallback {
override fun onCallBack(value: String) {
TODO("Not yet implemented")
}
})
}
接著我們使用Kotlin協程提供的 suspendCoroutine 讓runTaskDefault具有返回值；
改造一下runTaskDefault ---> runTaskWithSuspend
suspend fun runTaskWithSuspend(): String {
// suspendCoroutine是一個掛起函式
return suspendCoroutine { continuation ->
runTask(object : SingleMethodCallback {
override fun onCallBack(value: String) {
continuation.resume(value)
}
})
}
}
這裡 suspendCoroutine是一個掛起函式，掛起函式只能在協程或者其他掛起函式中被呼叫，同時我們在回撥中將結果值傳入到Coutination的resume方法中；
經過我們上述的操作將回調方法具有返回值了；
suspendCancellableCoroutine 的使用
Success And Failure 類別的介面
宣告 success and failure 型別的介面
/**
* @author : zhangqi
* @time : 6/22/21
* desc :
*/
interface ICallBack {
fun onSuccess(data: String)
fun onFailure(t: Throwable)
}
同樣我們模擬一個耗時操作，在獲取結果的時候 呼叫 onSuccess()將結果回撥給實現，出現錯誤呼叫onFailure將錯誤交給實現處理
/**
* 模擬一個耗時操作
*/
private fun request(callback: ICallBack) {
thread {
try {
callback.onSuccess("success")
} catch (e: Exception) {
callback.onFailure(e)
}
}
}
最後我們呼叫requet方法，傳入介面的實現，
private fun requestDefault() {
request(object : ICallBack {
override fun onSuccess(data: String) {
// doSomething
}
override fun onFailure(t: Throwable) {
// handle Exception
}
})
}
同樣我們使用Kotlin協程提供的掛起函式將 requestDefault()改造成 具有返回值的函式 requestWithSuspend()
只不過我們這裡使用了 suspendCancellablkeCoroutine ,程式碼上見吧！
private suspend fun requestWithSuspend(): String {
return suspendCancellableCoroutine { cancellableContinuation->
request(object : ICallBack {
override fun onSuccess(data: String) {
cancellableContinuation.resume(data)
}
override fun onFailure(t: Throwable) {
cancellableContinuation.resumeWithException(t)
}
})
}
}
suspendCancellableCoroutine 是一個掛起函式，我們將requestWithSuspend宣告稱掛起函式
在onSucess()中我們我們呼叫CancellableContinue # resume 方法將結果返回，在onFailure呼叫CancellableContinuation # resumeWithException 將異常傳入進去；
呼叫requestWithSuspend()
private fun runRequestSuspend() {
try {
viewModelScope.launch {
val value = requestWithSuspend()
}
} catch (e: Exception) {
e.printStackTrace()
}
}
在ViewModel中Kotlin協程提供了 viewModelScope 來開啟一個協程，改協程是具有宣告週期的與當前ViewModel保持一致；
這裡我們使用了try{}catch 將我們開啟的協程處理了下，呼叫成功獲取到value值，出現錯誤我們在catch塊中除了一下；
以上就是 我們兩種日常遇見頻率較高的情況進行的改造（回撥方法具有返回值）
Retrofit是如何支援協程的
Retrofit是在2.6版本開始支援，我們先對比下使用協程前後的區別
使用協前
/**
* 發現頁面的資料
*/
@GET("/api/v7/index/tab/discovery")
fun getDiscoveryData(): Call<OpenEyeResponse>
// 在ViewModel中呼叫
/**
* 沒有使用協程做網路請求
*/
fun getDiscoverData() {
WidgetService.openEyeInstance.getDiscoveryData().enqueue(object : Callback<OpenEyeResponse> {
override fun onResponse(call: Call<OpenEyeResponse>, response: Response<OpenEyeResponse>) {
var body = response.body()
}
override fun onFailure(call: Call<OpenEyeResponse>, t: Throwable) {
}
})
}
接著我們看下使用協程後
使用協程後
/**
* 通過協程做本次請求
* @return OpenEyeResponse
*/
@GET("/api/v7/index/tab/discovery")
suspend fun getDiscoveryDataCoroutine(): OpenEyeResponse
/**
* 使用協程做的請求
*/
fun getDiscoverDataWithCoroutine() {
try {
viewModelScope.launch {
var discoveryDataCoroutine = WidgetService.openEyeInstance.getDiscoveryDataCoroutine()
}
} catch (e: Exception) {
}
}
可以看見，在介面類中宣告的方法宣告為掛起函式，同時我們可以將我們想要的資料結構直接返回不用Call包一層；
Retrofit支援協程
Retrofit # HttpServiceMethod
okhttp3.Call.Factory callFactory = retrofit.callFactory;
if (!isKotlinSuspendFunction) {
return new CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter);
// 當是直接返回資料結構走這裡
} else if (continuationWantsResponse) {
//noinspection unchecked Kotlin compiler guarantees ReturnT to be Object.
return (HttpServiceMethod<ResponseT, ReturnT>)
// 執行了 SuspendForResponse
new SuspendForResponse<>(
requestFactory,
callFactory,
responseConverter,
(CallAdapter<ResponseT, Call<ResponseT>>) callAdapter);
} else {
//noinspection unchecked Kotlin compiler guarantees ReturnT to be Object.
return (HttpServiceMethod<ResponseT, ReturnT>)
new SuspendForBody<>(
requestFactory,
callFactory,
responseConverter,
(CallAdapter<ResponseT, Call<ResponseT>>) callAdapter,
continuationBodyNullable);
}
SuspendForResponse ---> KotlinExtensions.awaitResponse
SuspendForResponse(
RequestFactory requestFactory,
okhttp3.Call.Factory callFactory,
Converter<ResponseBody, ResponseT> responseConverter,
CallAdapter<ResponseT, Call<ResponseT>> callAdapter) {
super(requestFactory, callFactory, responseConverter);
this.callAdapter = callAdapter;
}
@Override
protected Object adapt(Call<ResponseT> call, Object[] args) {
call = callAdapter.adapt(call);
//noinspection unchecked Checked by reflection inside RequestFactory.
Continuation<Response<ResponseT>> continuation =
(Continuation<Response<ResponseT>>) args[args.length - 1];
// See SuspendForBody for explanation about this try/catch.
try {
// 在這裡直接呼叫了 KotlinExtensions.awaitResponse
return KotlinExtensions.awaitResponse(call, continuation);
} catch (Exception e) {
return KotlinExtensions.suspendAndThrow(e, continuation);
}
}
KotlinExtensions.awaitResponse
suspend fun <T> Call<T>.awaitResponse(): Response<T> {
// 在這裡使用了suspendCancellableCoroutine
return suspendCancellableCoroutine { continuation ->
// 當我們開啟的協程開啟了之後，會回撥到這個方法
// 取消當前的請求
continuation.invokeOnCancellation {
cancel()
}
enqueue(object : Callback<T> {
override fun onResponse(call: Call<T>, response: Response<T>) {
// 當成功拿到response之後 將response返回
continuation.resume(response)
}
override fun onFailure(call: Call<T>, t: Throwable) {
// 失敗的話 直接將異常丟擲
continuation.resumeWithException(t)
}
})
}
}