Kotlin协程请求网络

本文记录一下Kotlin协程如何配合其他网络请求框架来进行网络请求。其中涉及的底层原理暂时不去关注。

本篇文章中使用到的接口来自wanandroid提供的公开接口。

相关代码可以参考KotlinAndroid中的CoroutineOkHttpNetActivity和CoroutineRetrofitNetActivity。

加入依赖

//使用kotlin的依赖
implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:1.3.71"

//在Android中使用协程需要添加此依赖
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.0'

Kotlin协程配合OkHttp

先初始化OkHttpClient

private lateinit var client: OkHttpClient
private lateinit var builder: OkHttpClient.Builder

override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_coroutine_net)

        builder = OkHttpClient.Builder()
                .readTimeout(5000, TimeUnit.MILLISECONDS)
                .writeTimeout(10000, TimeUnit.MILLISECONDS)

        client = builder
                .build()
}

OkHttp正常发起网络请求

private fun normalRequest() {
    //请求公众号列表
    val request = Request.Builder()
            .url("https://wanandroid.com/wxarticle/chapters/json")
            .build()

    client.newCall(request).enqueue(object : okhttp3.Callback {

        override fun onFailure(call: okhttp3.Call, e: IOException) {
            Log.d(TAG, "onFailure: ${e.message}")
        }

        override fun onResponse(call: okhttp3.Call, response: okhttp3.Response) {
            val string = response.body()?.string()
            Log.d(TAG, "正常请求 onResponse: $string")
            //切换到主线程
            runOnUiThread {
                tvResult.text = "正常请求 onResponse: $string"
            }
        }
    })
}

协程配合OkHttp正常发起网络请求

  1. 首先给okhttp3.Call添加一个扩展函数，就是对okhttp3.Call的enqueue方法做了一个包装。
suspend fun okhttp3.Call.awaitResponse(): okhttp3.Response {

    return suspendCancellableCoroutine {

      it.invokeOnCancellation {
            //当协程被取消的时候，取消网络请求
            cancel()
        }

        enqueue(object : okhttp3.Callback {
            override fun onFailure(call: okhttp3.Call, e: IOException) {
                it.resumeWithException(e)
            }

            override fun onResponse(call: okhttp3.Call, response: okhttp3.Response) {
                it.resume(response)
            }
        })
    }
}

然后我们在Activity中使用

class CoroutineOkHttpNetActivity : AppCompatActivity(), CoroutineScope by MainScope() {

    override fun onDestroy() {
        super.onDestroy()
        //取消所有的任务
        this.cancel()
    }

}

我们实现了CoroutineScope接口，然后我们将CoroutineScope的实现委托给MainScope。注意要在onDestroy的时候取消所有的任务。

发起请求

 //注释1处
val exceptionHandler = CoroutineExceptionHandler { coroutineContext, throwable ->
    Log.d(TAG, "coroutine: error ${throwable.message}")
}

private fun coroutineRequest() {
    //请求公众号列表
    val request1 = Request.Builder()
            .url("https://wanandroid.com/wxarticle/chapters/json")
            .build()

    //使用exceptionHandler
    launch(exceptionHandler) {//这个协程是使用的MainScope，是在主线程

        //注释2处
        val response = client.newCall(request1).awaitResponse()
        //注释3处
        val string = getString(response)
        //更新UI
        tvResult.text = "协程请求 onResponse: $string"
    }
}

注释1处，我们定义了一个CoroutineExceptionHandler，用来捕获处理异常信息。关于异常处理的内容后面会单独写一篇文章。

注释2处，调用awaitResponse方法发起网络请求。内部就是调用okhttp3.Call的enqueue方法在后台发起网络请求。

注释3处，因为okhttp3.ResponseBody的string方法是一个IO操作，可能会比较耗时。所以我们通过一个挂起函数将这个操作放在后台线程执行。

private suspend fun getString(response: Response): String {
    return withContext(Dispatchers.IO) {
        response.body()?.string() ?: "empty string"
    }
}

我们在开发过程中，通常会遇到这样的场景：发起两次网络请求，第二次网络请求要依赖于第一次网络请求的结果。那我们该怎么写呢？

我们先获取公众号列表，然后查看列表中第一个公众号的历史数据。

private fun coroutineRequest() {
    val request1 = Request.Builder()
            .url("https://wanandroid.com/wxarticle/chapters/json")
            .build()

    launch(exceptionHandler) {
        //第一个网络请求
        val response1 = client.newCall(request1).awaitResponse()
        val string1 = getString(response1)
        val wxArticleResponse = JsonUtilKt.instance.toObject(string1, WxArticleResponse::class.java)

        //第二个网络请求依赖于第一个网络请求结果
        val firstWxId = wxArticleResponse?.data?.get(0)?.id ?: return@launch
        //第二个网络请求
        val request2 = Request.Builder()
                .url("https://wanandroid.com/wxarticle/list/${firstWxId}/1/json")
                .build()
        val response2 = client.newCall(request2).awaitResponse()
        val string2 = getString(response2)

        tvResult.text = "协程请求 onResponse: ${string2}"
    }
}

我们可以看到两次网络请求可以顺序书写下来，没有回调嵌套，非常简洁。

我们有时还会遇到这样的场景，需要将两次网络请求的结果合并到一起再进行下一步的操作，但是两个网络请求是没有依赖关系的，可以并发进行。我们该怎么写呢？

我们两次获取公众号列表，然后将结果合并起来。

如果按照上面的例子，我们可以这样写：

private fun coroutineRequest() {
    val request1 = Request.Builder()
            .url("https://wanandroid.com/wxarticle/chapters/json")
            .build()
    val request2 = Request.Builder()
            .url("https://wanandroid.com/wxarticle/chapters/json")
            .build()
    launch(exceptionHandler) {
        val startTime = System.currentTimeMillis()
        //注释1处，发起两次请求    
        val response1 = client.newCall(request1).awaitResponse()
        val response2 = client.newCall(request2).awaitResponse()

        Log.d(TAG, "coroutineRequest: 网络请求消耗时间：${System.currentTimeMillis() - startTime}")
        val string1 = getString(response1)
        val string2 = getString(response2)
            
        //合并两次请求的结果更新UI
        tvResult.text = "协程请求 onResponse: ${string1 + string2}"
    }
}

这种写法是不合适的，为什么呢？因为这两次请求是顺序执行的。在我的设备上多次执行coroutineRequest方法，两次网络请求最少的耗时时间是70毫秒。打印日志：

D/CoroutineOkHttpNetActiv: coroutineRequest: 网络请求消耗时间：70

正确的写法，并行发起请求。

private fun coroutineRequest3() {
    val request1 = Request.Builder()
            .url("https://wanandroid.com/wxarticle/chapters/json")
            .build()
    val request2 = Request.Builder()
            .url("https://wanandroid.com/wxarticle/chapters/json")
            .build()

    launch(exceptionHandler) {
        val startTime = System.currentTimeMillis()
        //两次网络请求没有依赖关系，可以并发请求
        val deferred1 = async { client.newCall(request1).awaitResponse() }
        val deferred2 = async { client.newCall(request2).awaitResponse() }
        val response1 = deferred1.await()
        val response2 = deferred2.await()
        Log.d(TAG, "coroutineRequest: 并发网络请求消耗时间：${System.currentTimeMillis() - startTime}")
        val string1 = getString(response1)
        val string2 = getString(response2)
        tvResult.text = "协程请求 onResponse: ${string1 + string2}"
    }
}

在我的设备上，并发执行两次网络请求最少的耗时时间是45毫秒。打印日志：

D/CoroutineOkHttpNetActiv: coroutineRequest: 并发网络请求消耗时间：45

Kotlin协程配合Retrofit

定义接口方法

interface ApiService {

    @GET("wxarticle/chapters/json")
    fun getWxarticle(): Call<WxArticleResponse>

}

构建接口实例

private val apiService = Retrofit.Builder()
            .baseUrl("https://www.wanandroid.com/")
            .addConverterFactory(GsonConverterFactory.create())
            .build().create(ApiService::class.java)

Retrofit正常请求

private fun normalRequest() {
    apiService.getWxarticle().enqueue(object : retrofit2.Callback<WxArticleResponse> {
        override fun onFailure(call: Call<WxArticleResponse>, t: Throwable) {
            Log.d(TAG, "onFailure: ${t.message}")
        }

        override fun onResponse(call: Call<WxArticleResponse>, response: retrofit2.Response<WxArticleResponse>) {
            if (response.isSuccessful) {
                val wxArticleResponse = response.body()
                val sb = StringBuilder("Retrofit正常请求：\n")
                wxArticleResponse?.data?.forEach {
                    sb.append(it.name)
                    sb.append("\n")
                }
                tvResult.text = sb.toString()
            }
        }
    })
}

协程配合Retrofit（2.6.0以下版本）正常网络请求

  1. 首先给Retrofit.Call类添加一个扩展函数，就是对retrofit2.Call的enqueue方法做了一个包装。
suspend fun <T : Any?> Call<T>.awaitResponse(): T {

    return suspendCancellableCoroutine {
        enqueue(object : Callback<T> {
            override fun onFailure(call: Call<T>, t: Throwable) {
                it.resumeWithException(t)
            }

            override fun onResponse(call: Call<T>, response: Response<T>) {
                if (response.isSuccessful) {
                    val body = response.body()
                    if (body != null) {
                        it.resume(body)
                    } else {
                        it.resumeWithException(Throwable(response.toString()))
                    }

                } else {
                    it.resumeWithException(Throwable(response.toString()))
                }
            }
        })
    }
}

在Activity中使用

class CoroutineOkHttpNetActivity : AppCompatActivity(), CoroutineScope by MainScope() {

    override fun onDestroy() {
        super.onDestroy()
        //取消所有的任务
        this.cancel()
    }

}

我们实现了CoroutineScope接口，然后我们将CoroutineScope的实现委托给MainScope。注意要在onDestroy的时候取消所有的任务。

发起请求

private fun coroutineRequest() {
    launch(exceptionHandler) {
         //需要借助Retrofit.Call类的扩展方法
         val response: WxArticleResponse = apiService.getWxarticle().awaitResponse()
         val sb = StringBuilder("Retrofit配合协程请求：\n")
         response.data.forEach {
             sb.append(it.name).append("\n")
         }
         tvResult.text = sb.toString()
    }
}

协程配合Retrofit（2.6.0及以上版本）发起网络请求

  1. 不再需要给给Retrofit.Call类添加扩展函数(Retrofit已经给我们添加好了)。
  2. 接口方法声明可以简化，方法返回类型直接声明成需要的数据类型。
interface ApiService {

    //Retrofit2.6.0以下方法声明
    //@GET("wxarticle/chapters/json")
    //fun getWxarticle(): Call<WxArticleResponse>

    //Retrofit2.6.0及以上方法声明
    @GET("wxarticle/chapters/json")
    suspend fun getWxarticle2(): WxArticleResponse

}

发起请求

private fun coroutineRequest2_6() {
    launch(exceptionHandler) {
        val response = apiService.getWxarticle2()
        val sb = StringBuilder("Retrofit2.6配合协程请求：\n")
        response.data.forEach { sb.append(it.name).append("\n") }
        tvResult.text = sb.toString()
    }
}

协程异常处理

上面的协程请求，为了捕获异常，我们声明了一个CoroutineExceptionHandler实例，然后使用。

val exceptionHandler = CoroutineExceptionHandler { _, exception ->
    Log.d(TAG, "Caught original $exception")
}

使用

private fun coroutineRequest2() {
    launch(exceptionHandler) {
        val response = apiService.getWxarticle2()
        val sb = StringBuilder("Retrofit2.6配合协程请求：\n")
        response.data.forEach { sb.append(it.name).append("\n") }
        tvResult.text = sb.toString()
    }
}

返回结果的统一处理

我们的返回结果通常有两种样式

样式1：data是一个JSONObject

{
  "data": {},
  "errorCode": 0,
  "errorMsg": ""
}

样式2：data是一个JSONArray

{
  "data": [],
  "errorCode": 0,
  "errorMsg": ""
}

首先定义通用的响应类

class NetResponse<T> {
    var data: T? = null
    var errorMsg = ""
    var errorCode = 0


    fun success() = errorCode == 0
}

Retrofit2.6.0以下格式统一处理

定义接口方法


//data是JSONObject
@GET("article/list/1/json")
fun getArticleLowLevelFormat1(): Call<NetResponse<Article>>

//data是JSONArray
@GET("wxarticle/chapters/json")
fun getWxarticleListLowLevelFormat2(): Call<NetResponse<MutableList<WxArticleResponse.DataBean>>>

使用

private fun handlerLowLevelResponseFormat1() {
    launch(exceptionHandler) {
        //需要借助Retrofit.Call类的扩展方法
        val response: NetResponse<Article> =
                apiService.getArticleLowLevelFormat1().awaitResponse()
        if (response.success()) {
            val sb = StringBuilder("Retrofit2.6以下响应格式统一处理1：\n")
            response.data?.datas?.forEach {
                sb.append(it.title).append("\n")
            }
            tvResult.text = sb.toString()
        } else {
           Log.d(TAG, "handlerLowLevelResponseFormat1: failed ${response.errorMsg}")
        }
    }
}

private fun handlerLowLevelResponseFormat2() {
    launch(handler) {
        val response: NetResponse<MutableList<WxArticleResponse.DataBean>> =
                apiService.getWxarticleListLowLevelFormat2().awaitResponse()
        if (response.success()) {
            val sb = StringBuilder("Retrofit2.6以下响应格式统一处理2：\n")
            response.data?.forEach {
                sb.append(it.name).append("\n")
                Log.d(TAG, "handlerLowLevelResponseFormat2: ${it.name}")
            }
            tvResult.text = sb.toString()
        } else {
            Log.d(TAG, "handlerLowLevelResponseFormat2: failed ${response.errorMsg}")
        }
    }
}

Retrofit2.6.0以上格式统一处理

定义接口方法

//data是JSONObject
@GET("article/list/1/json")
suspend fun getArticle(): NetResponse<Article>

//data是JSONArray
@GET("wxarticle/chapters/json")
suspend fun getWxarticleList(): NetResponse<MutableList<WxArticleResponse.DataBean>>

使用

 private fun handlerResponseFormat1() {
    launch(handler) {
        val response = apiService.getArticle()
        if (response.success()) {
            val article: Article? = apiService.getArticle().data
            val sb = StringBuilder("handlerResponseFormat1：\n")

            article?.datas?.forEach {
                sb.append(it.title).append("\n")
                Log.d(TAG, "handlerResponseFormat1: ${it.title}")
            }
            tvResult.text = sb.toString()
        } else {
            Log.d(TAG, "handlerResponseFormat1: failed ${response.errorMsg}")
        }
    }
}

private fun handlerResponseFormat2() {
    launch(handler) {
        val response = apiService.getWxarticleList()
        if (response.success()) {
            val articleList: MutableList<WxArticleResponse.DataBean>? = response.data
            val sb = StringBuilder("handlerResponseFormat2：\n")
            articleList?.forEach {
                sb.append(it.name)append("\n")
                Log.d(TAG, "handlerResponseFormat2: ${it.name}")
            }
            tvResult.text = sb.toString()
        } else {
            Log.d(TAG, "handlerResponseFormat2: failed ${response.errorMsg}")
        }
    }
}

参考链接：

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 158,560评论 4赞 361
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 67,104评论 1赞 291
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 108,297评论 0赞 243
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 43,869评论 0赞 204
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 52,275评论 3赞 287
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 40,563评论 1赞 216
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 31,833评论 2赞 312
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 30,543评论 0赞 197
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 34,245评论 1赞 241
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 30,512评论 2赞 244
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 32,011评论 1赞 258
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 28,359评论 2赞 253
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 33,006评论 3赞 235
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 26,062评论 0赞 8
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 26,825评论 0赞 194
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 35,590评论 2赞 273
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 35,501评论 2赞 268