Kotlin协程 ----- suspendCoroutine和suspendCancellableCoroutine的使用
简介
- 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)
}
})
}
}
