正文

RxHttp ，比Retrofit 更优雅的协程体验

IP云
IP云V管理员/6 阅读
11/25
小程序：扫一扫查出行
【扫一扫了解最新限行尾号】
复制小程序

1、前言

Hello，各位小伙伴，又见面了，回首过去，RxHttp 就要迎来一周年生日了(19年4月推出)，这一年，走过来真心....真心不容易，代码维护、写文章、写文档等等，经常都是干到零点之后，也是我首次花费大部分业余时间来维护一个开源项目，全程一个人维护，要知道，网络请求库不同于其它开源项目，各位同僚对这类项目的要求都非常高，而且前面有一座大山Retrofit，如何在这种情况下，杀出重围？那就只有死磕细节，做到 人无我有，人有我精 。

幸运的是，RxHttp它做到了，截止本文发表，在Github上，已达到1600+star，在RxHttp$RxLife交流群（群号：378530627，经常会有技术交流，欢迎进群）也有了300+人，这次，RxHttp 更新到了2.x版本，给大家带来不一样的协程体验，为啥不一样？看完本文你会有答案

gradle依赖 

dependencies {

   //必须

   implementation 'com.ljx.rxhttp:rxhttp:2.2.0'

   annotationProcessor 'com.ljx.rxhttp:rxhttp-compiler:2.2.0' //生成RxHttp类

   //以下均为非必须

   implementation 'com.ljx.rxlife:rxlife-coroutine:2.0.0'  //管理协程生命周期，页面销毁，关闭请求

   implementation 'com.ljx.rxlife2:rxlife-rxjava:2.0.0'    //管理RxJava2生命周期，页面销毁，关闭请求

   implementation 'com.ljx.rxlife3:rxlife-rxjava:3.0.0'    //管理RxJava3生命周期，页面销毁，关闭请求

   //Converter 根据自己需求选择 RxHttp默认内置了GsonConverter

   implementation 'com.ljx.rxhttp:converter-jackson:2.2.0'

   implementation 'com.ljx.rxhttp:converter-fastjson:2.2.0'

   implementation 'com.ljx.rxhttp:converter-protobuf:2.2.0'

   implementation 'com.ljx.rxhttp:converter-simplexml:2.2.0'

}

注：纯Java项目，请使用annotationProcessor替代kapt；依赖完，记得rebuild，才会生成RxHttp类

RxHttp2.2.0版本起，已完全剔除了RxJava，采用外挂的方法替代，支持RxJava2、RxJava3，详情查看RxHttp上手

遇到问题，点这里，点这里，点这里，99%的问题都能自己解决

本文只介绍RxHttp与协程相关的部分，如果你之前没有了解过RxHttp，建议先阅读RxHttp 让你眼前一亮的Http请求框架一文

如果你现在对协程还一知半解，没有关系，那是因为你还没有找到运用场景，而网络请求正是一个很好的切入场景，本文会教你如何优雅，并且安全的开启协程，以及用协程处理多任务，用着用着你就会了。

2、RxHttp 协程使用

用过RxHttp的同学知道，RxHttp发送任意请求都遵循请求三部曲，如下：

代码表示 

RxHttp.get("/service/...") //第一步，确定请求方式，可以选择postForm、postJson等方法

    .asString()            //第二步，使用asXXX系列方法确定返回类型

    .subscribe(s -> {      //第三步, 订阅观察者

        //成功回调

    }, throwable -> {

        //失败回调

    });

这使得初学者非常容易上手，掌握了请求三部曲，就掌握了RxHttp的精髓，而协程，亦遵循请求三部曲，如下：



代码表示 

val str = RxHttp.get("/service/...") //第一步，确定请求方式，可以选择postForm、postJson等方法

    .toStr()    //第二步，确认返回类型，这里代表返回String类型

    .await()    //第二步，使用await方法拿到返回值

注: await() 是suspend挂断方法，需要在另一个suspend方法或协程环境中调用

接着，如果我们要获取一个 Student 对象或者 List<Student> 集合对象等等任意数据类型，也是通过 await() 方法，如下： 

//Student对象

val student = RxHttp.get("/service/...")

    .toClass<Student>()

    .await()

//List<Student> 对象

val students = RxHttp.get("/service/...")

    .toClass<List<Student>>()

    .await()

toClass() 方法是万能的，它可以拿到任意数据类型，我们来看下 toClass() 方法的完整签名 

inline fun <reified T : Any> IRxHttp.toClass() : IAwait<T>

可以看到，它没有任何参数，只是声明了一个泛型 T ，并将它作为了返回类型，所以通过该方法，就可以拿到任意数据类型。

以上就是RxHttp在协程中最常规的操作，接下来，上真正的干货

2.1、业务code统一判断

我想大部分人的接口返回格式都是这样的 

class Response<T> {

    var code = 0

    var msg : String? = null

    var data : T

}

拿到该对象的第一步就是对code做判断，如果 code != 200 (假设200代码数据正确)，就会拿到msg字段给用户一些错误提示，如果等于200，就拿到data字段去更新UI，常规的操作是这样的 

val response = RxHttp.get("/service/...")

    .toClass<Response<Student>>()

    .await()

if (response.code == 200) {

    //拿到data字段(Student)刷新UI

} else {

    //拿到msg字段给出错误提示

}

试想一下，一个项目少说也有30+个这样的接口，如果每个接口读取这么判断，就显得不够优雅，也可以说是灾难，相信也没有人会这么干。而且对于UI来说，只需要data字段即可，错误提示啥的我管不着。

那有没有什么办法，能直接拿到data字段，并且对code做出统一判断呢？有的，直接上代码 

val student = RxHttp.get("/service/...")

    .toResponse<Student>() //调用此方法，直接拿到data字段，也就是Student对象

    .await()

//直接开始更新UI

可以看到，这里调用了 toResponse() 方法，就直接拿到了data字段，也就是Student对象。

此时，相信很多人会有疑问，

  • 业务code哪里判断的？

  • 业务code非200时，msg字段怎么拿到？

为此，先来回答第一个问题，业务code哪里判断的？

其实 toResponse() 方法并不是RxHttp内部提供的，而是用户通过自定义解析器，并用 @Parser 注解标注，最后由注解处理器 rxhttp-compiler 自动生成的，听不懂？没关系，直接看代码 

@Parser(name = "Response")

open class ResponseParser<T> : AbstractParser<T> {

    //以下两个构造方法是必须的

    protected constructor() : super()

    constructor(type: Class<T>) : super(type)

    @Throws(IOException::class)

    override fun onParse(response: okhttp3.Response): T {

        val type: Type = ParameterizedTypeImpl[Response::class.java, mType] //获取泛型类型

        val data: Response<T> = convert(response, type)   //获取Response对象

        val t = data.data                             //获取data字段

        if (data.code != 200 || t == null) { //code不等于200，说明数据不正确，抛出异常

            throw ParseException(data.code.toString(), data.msg, response)

        }

        return t

    }

}

上面代码只需要关注两点即可，

第一点，我们在类开头使用了 @Parser 注解，并为解析器取名为 Response ，所以就有了 toResponse() 方法（命名方式为：to + Parser注解里设置的名字）；

第二点，我们在 if 语句里，对code做了判断，非200或者data为空时，就抛出异常，并带上了code及msg字段，所以我们在异常回调的地方就能拿到这两个字段

接着回答第二个问题，code非200时，如何拿到msg字段？直接上代码，看一个使用协程发送请求的完整案例 

//当前环境在Fragment中

fun getStudent() {

    //rxLifeScope在rxLife-coroutine库中，需要单独依赖

    rxLifeScope.launch({    //通过launch方法开启一个协程

        val student = RxHttp.get("/service/...")

            .toResponse<Student>()

            .await()

    }, {

        //异常回调，这里的it为Throwable类型

        val code = it.code

        val msg = it.msg

    })

}

注：RxLifeScope 是 RxLife-Coroutine库中的类，本文后续会详细介绍

上面的代码，在异常回调中便可拿到code及msg字段，需要注意的是， it.code 及 it.msg 是我为Throwable类扩展的两个属性，代码如下： 

val Throwable.code: Int

    get() {

        val errorCode = when (this) {

            is HttpStatusCodeException -> this.statusCode //Http状态码异常

            is ParseException -> this.errorCode     //业务code异常

            else -> "-1"

        }

        return try {

            errorCode.toInt()

        } catch (e: Exception) {

            -1

        }

    }

val Throwable.msg: String

    get() {

        return if (this is UnknownHostException) { //网络异常

            "当前无网络，请检查你的网络设置"

        } else if (

            this is SocketTimeoutException  //okhttp全局设置超时

            || this is TimeoutException     //rxjava中的timeout方法超时

            || this is TimeoutCancellationException  //协程超时

        ) {

            "连接超时,请稍后再试"

        } else if (this is ConnectException) {

            "网络不给力，请稍候重试！"

        } else if (this is HttpStatusCodeException) {               //请求失败异常

            "Http状态码异常"

        } else if (this is JsonSyntaxException) {  //请求成功，但Json语法异常,导致解析失败

            "数据解析失败,请检查数据是否正确"

        } else if (this is ParseException) {       // ParseException异常表明请求成功，但是数据不正确

            this.message ?: errorCode   //msg为空，显示code

        } else {

            "请求失败，请稍后再试"

        }

    }

到这，业务code统一判断就介绍完毕，上面的代码，大部分人都可以简单修改后，直接用到自己的项目上，如 ResponseParser 解析器，只需要改下 if 语句的判断条件即可

2.2、retry 失败重试

OkHttp为我们提供了全局的失败重试机制，然而，这远远不能满足我们的需求，比如，我就部分接口需要失败重试，而不是全局的；我需要根据某些条件来判断是否需要重试；亦或者我需要周期性重试，即间隔几秒后重试等等

那RxHttp协程是如何解决这些问题的呢？RxHttp提供了一个 retry() 方法来解决这些难题，来看下完整的方法签名 

/**

 * 失败重试，该方法仅在使用协程时才有效

 * @param times  重试次数, 默认Int.MAX_VALUE 代表不断重试

 * @param period 重试周期, 默认为0, 单位: milliseconds

 * @param test   重试条件, 默认为空，即无条件重试

 */

fun retry(

    times: Int = Int.MAX_VALUE,

    period: Long = 0,

    test: ((Throwable) -> Boolean)? = null

)

retry() 方法共有3个参数，分别是重试次数、重试周期、重试条件，都有默认值，3个参数可以随意搭配，如： 

retry()    //无条件、不间断、一直重试

retry(2)   //无条件、不间断、重试两次

retry(2, 1000)   //无条件 间隔1s 重试2此

retry { it is ConnectException } //有条件、不间断、一直重试

retry(2) { it is ConnectException }  //有条件、不间断、重试2次

retry(2, 1000) { it is ConnectException }  //有条件、间隔1s、重试2次

retry(period = 1000) { it is ConnectException } //有条件、间断1s、一直重试

前两个参数相信大家一看就能明白，这里对第3个参数额外说一下，通过第三个参数，我们可以拿到 Throwable 异常对象，我们可以对异常做判断，如果需要重试，就返回true，不需要就返回false，下面看看具体代码 

val student = RxHttp.postForm("/service/...")

    .toResponse<Student>()

    .retry(2, 1000) {       //重试2次，每次间隔1s

        it is ConnectException   //如果是网络异常就重试

    }

    .await()

2.3、timeout 超时

OkHttp提供了全局的读、写及连接超时，有时我们也需要为某个请求设置不同的超时时长，此时就可以用到RxHttp的 timeout(Long) 方法，如下： 



val student = RxHttp.postForm("/service/...")

    .toResponse<Student>()

    .timeout(3000)      //超时时长为3s

    .await()

2.4、async 异步操作符

如果我们由两个请求需要并行时，就可以使用该操作符，如下： 

//同时获取两个学生信息

suspend void initData() {

  val asyncStudent1 = RxHttp.postForm("/service/...")

    .toResponse<Student>()

    .async()   //这里会返回Deferred<Student>  

  val asyncStudent2 = RxHttp.postForm("/service/...")

    .toResponse<Student>()

    .async()   //这里会返回Deferred<Student>  

  //随后调用await方法获取对象

  val student1 = asyncStudent1.await()

  val student2 = asyncStudent2.await()

}

2.5、delay、startDelay 延迟

delay 操作符是请求结束后，延迟一段时间返回；而 startDelay 操作符则是延迟一段时间后再发送请求，如下： 

val student = RxHttp.postForm("/service/...")

    .toResponse<Student>()

    .delay(1000)      //请求回来后，延迟1s返回

    .await()       

val student = RxHttp.postForm("/service/...")

    .toResponse<Student>()

    .startDelay(1000)     //延迟1s后再发送请求

    .await()

2.6、onErrorReturn、onErrorReturnItem异常默认值

有些情况，我们不希望请求出现异常时，直接走异常回调，此时我们就可以通过两个操作符，给出默认的值，如下： 

//根据异常给出默认值

val student = RxHttp.postForm("/service/...")

    .toResponse<Student>()

    .timeout(100)      //超时时长为100毫秒

    .onErrorReturn {

        //如果时超时异常，就给出默认值，否则，抛出原异常

        return@onErrorReturn if (it is TimeoutCancellationException)

            Student()

        else

            throw it

    }

    .await()

//只要出现异常，就返回默认值

val student = RxHttp.postForm("/service/...")

    .toResponse<Student>()

    .timeout(100)      //超时时长为100毫秒

    .onErrorReturnItem(Student())

    .await()

2.7、tryAwait 异常返回null

如果你不想在异常时返回默认值，又不想异常是影响程序的执行， tryAwait 就派上用场了，它会在异常出现时，返回null，如下： 

val student = RxHttp.postForm("/service/...")

    .toResponse<Student>()

    .timeout(100)      //超时时长为100毫秒

    .tryAwait()     //这里返回 Student? 对象，即有可能为空

2.8 map 转换符号

map 操作符很好理解，RxJava即协程的Flow都有该操作符，功能都是一样，用于转换对象，如下： 

val student = RxHttp.postForm("/service/...")

    .toStr()

    .map { it.length }  //String转Int

    .tryAwait()     //这里返回 Student? 对象，即有可能为空

2.9、以上操作符随意搭配

以上操作符，可随意搭配使用，但调用顺序的不同，产生的效果也不一样，这里先告诉大家，以上操作符只会对上游代码产生影响。

如 timeout及retry ： 

val student = RxHttp.postForm("/service/...")

    .toResponse<Student>()

    .timeout(50)

    .retry(2, 1000) { it is TimeoutCancellationException }

    .await()

以上代码，只要出现超时，就会重试，并且最多重试两次。

但如果 timeout 、 retry 互换下位置，就不一样了，如下： 

val student = RxHttp.postForm("/service/...")

    .toResponse<Student>()

    .retry(2, 1000) { it is TimeoutCancellationException }

    .timeout(50)

    .await()

此时，如果50毫秒内请求没有完成，就会触发超时异常，并且直接走异常回调，不会重试。为什么会这样？原因很简单， timeout及retry 操作符，仅对上游代码生效。如retry操作符，下游的异常是捕获不到的，这就是为什么timeout在retry下，超时时，重试机制没有触发的原因。

在看 timeout 和 startDelay 操作符 

val student = RxHttp.postForm("/service/...")

    .toResponse<Student>()

    .startDelay(2000)

    .timeout(1000)

    .await()

以上代码，必定会触发超时异常，因为startDelay，延迟了2000毫秒，而超时时长只有1000毫秒，所以必定触发超时。

但互换下位置，又不一样了，如下： 

val student = RxHttp.postForm("/service/...")

    .toResponse<Student>()

    .timeout(1000)

    .startDelay(2000)

    .await()

以上代码正常情况下，都能正确拿到返回值，为什么？原因很简单，上面说过，操作符只会对上游产生影响，下游的 startDelay 延迟，它是不管的，也管不到。

3、上传/下载

RxHttp对文件的优雅操作是与生俱来的，在协程的环境下，依然如此，没有什么比代码更具有说服力，直接上代码

3.1、文件上传 
 val result = RxHttp.postForm("/service/...")

     .addFile("file", File("xxx/1.png"))        //添加单个文件

     .addFile("fileList", ArrayList<File>())    //添加多个文件

     .toResponse<String>()

     .await()

只需要通过 addFile 系列方法添加File对象即可，就是这么简单粗暴，想监听上传进度？简单，再加一个 upload 操作符即可，如下： 

val result = RxHttp.postForm("/service/...")

    .addFile("file", File("xxx/1.png"))

    .addFile("fileList", ArrayList<File>())

    .upload(this) {    //此this为CoroutineScope对象，即当前协程对象

        //it为Progress对象

        val process = it.progress         //已上传进度  0-100

        val currentSize = it.currentSize  //已上传size，单位：byte

        val totalSize = it.totalSize      //要上传的总size  单位：byte

    }

    .toResponse<String>()

    .await()

我们来看下 upload 方法的完整签名，如下： 

/**

 * 调用此方法监听上传进度

 * @param coroutine  CoroutineScope对象，用于开启协程，回调进度，进度回调所在线程取决于协程所在线程

 * @param progress 进度回调

 * 注意：此方法仅在协程环境下才生效

 */

fun RxHttpFormParam.upload(

    coroutine: CoroutineScope? = null,

    progress: (Progress) -> Unit

):RxHttpFormParam

3.2、文件下载

接着再来看看下载，直接贴代码 

val localPath = "sdcard//android/data/..../1.apk"

val student = RxHttp.get("/service/...")

    .toDownload(localPath)  //下载需要传入本地文件路径

    .await()

下载调用 toDownload(String) 方法，传入本地文件路径即可，要监听下载进度？也简单，如下： 

val localPath = "sdcard//android/data/..../1.apk"

val student = RxHttp.get("/service/...")

    .toDownload(localPath, this) {   //此this为CoroutineScope对象

        //it为Progress对象

        val process = it.progress        //已下载进度 0-100

        val currentSize = it.currentSize //已下载size，单位：byte

        val totalSize = it.totalSize     //要下载的总size 单位：byte

    }

    .await()

看下 toDownload 方法完整签名 

/**

 * @param destPath 本地存储路径

 * @param coroutine CoroutineScope对象，用于开启协程，回调进度，进度回调所在线程取决于协程所在线程

 * @param progress 进度回调

 */

fun IRxHttp.toDownload(

    destPath: String,

    coroutine: CoroutineScope? = null,

    progress: (Progress) -> Unit

): IAwait<String>

如果你需要断点下载，也是可以的，一行代码的事，如下： 

val localPath = "sdcard//android/data/..../1.apk"

val student = RxHttp.get("/service/...")

    .setRangeHeader(1000, 300000)   //断点下载，设置下载起始/结束位置

    .toDownload(localPath, this) { //此this为CoroutineScope对象

        //it为Progress对象

        val process = it.progress        //已下载进度 0-100

        val currentSize = it.currentSize //已下size，单位：byte

        val totalSize = it.totalSize     //要下的总size 单位：byte

    }

    .await()

老规则，看下 setRangeHeader 完整签名 

/**

 * 设置断点下载开始/结束位置

 * @param startIndex 断点下载开始位置

 * @param endIndex 断点下载结束位置，默认为-1，即默认结束位置为文件末尾

 * @param connectLastProgress 是否衔接上次的下载进度，该参数仅在带进度断点下载时生效

 */

fun setRangeHeader (

    startIndex: Long,

    endIndex: Long = 0L,

    connectLastProgress: Boolean = false

)

到这，RxHttp协程的基础Api基本介绍完毕，那么问题了，以上介绍的Api都依赖与协程环境，那我这么开启协程呢？亦或者说，我对协程不是很懂，你只要保证安全的前提下，告诉怎么用就行了，ok，那下面如何安全的开启一个协程，做到自动异常捕获，且页面销毁时，自动关闭协程及请求

4、协程开启及关闭

此时就要引入本人开源的另一个库RxLife-Coroutine，用于开启/关闭协程，并自动异常捕获，依赖如下： 

implementation 'com.ljx.rxlife:rxlife-coroutine:2.0.0'

本文在介绍业务code统一处理的时候，我们用到rxLifeScope属性开启协程，那这个是什么类型呢？看代码 

val ViewModel.rxLifeScope: RxLifeScope

    get() {

        val scope: RxLifeScope? = this.getTag(JOB_KEY)

        if (scope != null) {

            return scope

        }

        return setTagIfAbsent(JOB_KEY, RxLifeScope())

    }

val LifecycleOwner.rxLifeScope: RxLifeScope

    get() = lifecycle.rxLifeScope

可以看到，我们为 ViewModel 及 LifecycleOwner 都扩展了一个名为 rxLifeScope 的属性，类型为 RxLifeScope ，ViewModel相信大家都知道了，这里就简单讲一下LifecycleOwner接口，我们的Fragment及FragmentActivity都实现了 LifecycleOwner 接口，而我们的Activity一般继承于AppCompatActivity，而AppCompatActivity继承于FragmentActivity，所以我们在 FragmentActivity/Fragment/ViewModel 环境下，可以直接使用 rxLifeScope 开启协程，如下： 

rxLifeScope.lanuch({

    //协程代码块，运行在UI线程

}, {

    //异常回调，协程代码块出现任何异常，都会直接走这里

})

通过这种方式开启的协程，会在页面销毁时，会自动关闭协程，当然，如果你的协程代码块里还有RxHttp请求的代码，协程关闭的同时，也是关闭请求，所以在这种情况下，只需要知道如何开启协程就行，其它一律不管。

现在，我们来看下 rxLifeScope.lanuch 方法的完整签名 

/**

 * @param block     协程代码块，运行在UI线程

 * @param onError   异常回调，运行在UI线程

 * @param onStart   协程开始回调，运行在UI线程

 * @param onFinally 协程结束回调，不管成功/失败，都会回调，运行在UI线程

 */

fun launch(

    block: suspend CoroutineScope.() -> Unit,

    onError: ((Throwable) -> Unit)? = null,

    onStart: (() -> Unit)? = null,

    onFinally: (() -> Unit)? = null

): Job

可以看到，不仅有失败回调，还有开始及结束回调，这对于我们发请求来说，真的非常方便，如下： 

rxLifeScope.launch({

    //协程代码块

    val students = RxHttp.postJson("/service/...")

        .toResponse<List<Student>>()

        .await()

    //可以直接更新UI

}, {

    //异常回调，这里可以拿到Throwable对象

}, {

    //开始回调，可以开启等待弹窗

}, {

    //结束回调，可以销毁等待弹窗

})

以上代码均运行在UI线程中，请求回来后，便可直接更新UI

也许你还有疑问，我在非 FragmentActivity/Fragment/ViewModel 环境下，如何开启协程，又如何关闭，其实也很简单，如下： 

val job = RxLifeScope().launch({

    val students = RxHttp.postJson("/service/...")

        .toResponse<List<Student>>()

        .await()

}, {

    //异常回调，这里可以拿到Throwable对象

}, {

    //开始回调，可以开启等待弹窗

}, {

    //结束回调，可以销毁等待弹窗

})

job.cancel()  //关闭协程

以上代码，需要注意两点，第一，我们需要手动创建 RxLifeScope() 对象，随后开启协程；第二，开启协程后，可以拿到 Job 对象，我们需要通过该对象手动关闭协程。其它就没啥区别了。

5、协程多任务处理

我们知道，协程最大的优势就是： 能以看起来同步的代码，写出异步的逻辑 ，这使得我们可以非常优雅的实现多任务场景，比如多请求的并行/串行

5.1、协程串行多个请求

假设，我们有这么一种场景，首先获取Student对象，随后通过studentId获取学生的家庭成员列表，后者依赖于前者，这是典型的串行场景

看看通过协程如何解决这个问题，如下： 

class MainActivity : AppCompatActivity() {

    //启动协程，发送请求

    fun sendRequest() {

        rxLifeScope.launch({

            //当前运行在协程中，且在主线程运行

            val student = getStudent()

            val personList = getFamilyPersons(student.id) //通过学生Id，查询家庭成员信息

            //拿到相关信息后，便可直接更新UI，如：

            tvName.text = student.name

        }, {

                //出现异常，就会到这里，这里的it为Throwable类型

            it.show("发送失败,请稍后再试!") //show方法是在Demo中扩展的方法

        })

    }

    //挂断方法，获取学生信息

    suspend fun getStudent(): Student {

        return RxHttp.get("/service/...")

            .add("key", "value")

            .addHeader("headKey", "headValue")

            .toClass<Student>()

            .await()

    }

    //挂断方法，获取家庭成员信息

    suspend fun getFamilyPersons(studentId: Int): List<Person> {

        return RxHttp.get("/service/...")

            .add("studentId", "studentId")

            .toClass<List<Person>>()

            .await()

    }

}

我们重点看下协程代码块，首先通过第一个请求拿到Student对象，随后拿到studentId，发送第二个请求获取学习家庭成员列表，拿到后，便可以直接更新UI，怎么样，是不是看起来同步的代码，写出了异步的逻辑。

串行请求中，只要其中一个请求出现异常，协程便会关闭（同时也会关闭请求），停止执行剩下的代码，接着走异常回调

5.2、协程并行多个请求

请求并行，在现实开发中，也是家常便饭，在一个Activity中，我们往往需要拿到多种数据来展示给用户，而这些数据，都是不同接口下发的。

如我们有这样一个页面，顶部是横向滚动的Banner条，Banner条下面展示学习列表，此时就有两个接口，一个获取Banner条列表，一个获取学习列表，它们两个互不依赖，便可以并行执行，如下： 

class MainActivity : AppCompatActivity() {

    //启动协程，发送请求

    fun sendRequest() {

        rxLifeScope.launch({

            //当前运行在协程中，且在主线程运行

            val asyncBanner = getBanners() //这里返回Deferred<List<Banner>>对象

            val asyncPersons = getStudents() //这里返回Deferred<List<Student>>对象

            val banners = asyncBanner.await()           //这里返回List<Banner>对象

            val students = asyncPersons.await()         //这里返回List<Student>对象

            //开始更新UI

        }, {

                //出现异常，就会到这里，这里的it为Throwable类型

            it.show("发送失败,请稍后再试!") //show方法是在Demo中扩展的方法

        })

    }

    //挂断方法，获取学生信息

    suspend fun getBanners(): Deferred<List<Banner>> {

        return RxHttp.get("/service/...")

            .add("key", "value")

            .addHeader("headKey", "headValue")

            .toClass<List<Banner>>()

            .async()  //注意这里使用async异步操作符

    }

    //挂断方法，获取家庭成员信息

    suspend fun getStudents(): Deferred<List<Student>> {

        return RxHttp.get("/service/...")

            .add("key", "value")

            .toClass<List<Student>>()

            .async() //注意这里使用async异步操作符

    }

}

在上述代码的两个挂断方法中，均使用了 async 异步操作符，此时这两个请求就并行发送请求，随后拿到 Deferred<T> 对象，调用其 await() 方法，最终拿到Banner列表及Student列表，最后便可以直接更新UI。

划重点

并行跟串行一样，如果其中一个请求出现了异常，协程便会自动关闭（同时关闭请求），停止执行剩下的代码，接着走异常回调。如果想多个请求互不影响，就可以使用上面介绍的 onErrorReturn 、 onErrorReturnItem 操作符，出现异常时，给出一个默认对象，又或者使用 tryAwait 操作符获取返回值，出现异常时，返回null，这样就不会影响其它请求的执行。

6、总结

看完本文，相信你已经领悟到了RxHttp优雅及简便，业务code的统一处理，失败重试、超时、文件上传/下载及进度监听，到后面 rxLifeScope 协程的开启/关闭/异常处理/多任务处理，一切都是那么的优雅。

其实，RxHttp远不止这些，本文只是讲解了RxHttp与协程相关的东西，更多优雅的功能，如：多/动态baseUrl的处理、公共参数/请求头的添加、请求加解密、缓存等等，请查看

RxHttp 让你眼前一亮的Http请求框架

RxHttp 全网Http缓存最优解

最后，开源不易，写文章更不易，还需要劳烦大家给本文点个赞，可以的话，再给个star，感觉不尽，

相关阅读

目录[+]