RxHttp ，比Retrofit 更优雅的协程体验
一、前言
Hello，各位小伙伴，又见面了，回首过去，RxHttp 就要迎来一周年生日了(19年4月推出)，这一年，走过来真心....真心不容易，代码维护、写文章、写文档等等，常常都是干到零点以后，也是我首次花费大部分业余时间来维护一个开源项目，全程一我的维护，要知道，网络请求库不一样于其它开源项目，各位同僚对这类项目的要求都很是高，并且前面有一座大山Retrofit，如何在这种状况下，杀出重围？那就只有死磕细节，作到人无我有，人有我精。java
幸运的是，RxHttp它作到了，截止本文发表，在Github上，已达到1600+star，在RxHttp$RxLife交流群（群号：378530627，常常会有技术交流，欢迎进群）也有了300+人，此次，RxHttp 更新到了2.x版本，给你们带来不同的协程体验，为啥不同？看完本文你会有答案android
gradle依赖git
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类github
RxHttp2.2.0版本起，已彻底剔除了RxJava，采用外挂的方法替代，支持RxJava二、RxJava3，详情查看RxHttp上手json
遇到问题，点这里，点这里，点这里，99%的问题都能本身解决缓存
本文只介绍RxHttp与协程相关的部分，若是你以前没有了解过RxHttp，建议先阅读RxHttp 让你眼前一亮的Http请求框架一文安全
若是你如今对协程还只知其一;不知其二，没有关系，那是由于你尚未找到运用场景，而网络请求正是一个很好的切入场景，本文会教你如何优雅，而且安全的开启协程，以及用协程处理多任务，用着用着你就会了。网络
二、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.一、业务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.二、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.三、timeout 超时
OkHttp提供了全局的读、写及链接超时，有时咱们也须要为某个请求设置不一样的超时时长，此时就能够用到RxHttp的timeout(Long)方法，以下：
val student = RxHttp.postForm("/service/...")
.toResponse<Student>()
.timeout(3000) //超时时长为3s
.await()
2.四、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.五、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.六、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.七、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.九、以上操做符随意搭配
以上操做符，可随意搭配使用，但调用顺序的不一样，产生的效果也不同，这里先告诉你们，以上操做符只会对上游代码产生影响。
如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延迟，它是无论的，也管不到。
三、上传/下载
RxHttp对文件的优雅操做是与生俱来的，在协程的环境下，依然如此，没有什么比代码更具备说服力，直接上代码
3.一、文件上传
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.二、文件下载
接着再来看看下载，直接贴代码
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，那下面如何安全的开启一个协程，作到自动异常捕获，且页面销毁时，自动关闭协程及请求
四、协程开启及关闭
此时就要引入本人开源的另外一个库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.一、协程串行多个请求
假设，咱们有这么一种场景，首先获取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.二、协程并行多个请求
请求并行，在现实开发中，也是屡见不鲜，在一个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，这样就不会影响其它请求的执行。
六、总结
看完本文，相信你已经领悟到了RxHttp优雅及简便，业务code的统一处理，失败重试、超时、文件上传/下载及进度监听，到后面rxLifeScope协程的开启/关闭/异常处理/多任务处理，一切都是那么的优雅。
其实，RxHttp远不止这些，本文只是讲解了RxHttp与协程相关的东西，更多优雅的功能，如：多/动态baseUrl的处理、公共参数/请求头的添加、请求加解密、缓存等等，请查看
最后，开源不易，写文章更不易，还须要劳烦你们给本文点个赞，能够的话，再给个star，感受不尽，🙏🙏🙏🙏🙏🙏🙏🙏🙏🙏🙏🙏
- 1. Retrofit 2.6.0 ! 更快捷的协程体验 ！
- 2. async 更优雅异步体验
- 3. Kotlin + 协程 + Retrofit + MVVM优雅的实现网络请求
- 4. 【思货】kotlin协程优雅的与Retrofit缠绵-正文
- 5. 【思货】kotlin协程优雅的与Retrofit缠绵-kotlin DSL简述
- 6. Retrofit+Rxjava网络层的优雅封装
- 7. retrofit-helper 简洁的封装retrofit，优雅的取消请求
- 8. RxHttp 优雅的实现请求串行与并行
- 9. Android OkHttp 史上最优雅的设置baseUrl
- 10. 优雅地使用Retrofit+RxJava(二)
- 更多相关文章...
- • MySQL的优势（优点） - MySQL教程
- • Lua 协同程序(coroutine) - Lua 教程
- • 算法总结-深度优先算法
- • 算法总结-广度优先算法
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. Retrofit 2.6.0 ! 更快捷的协程体验 ！
- 2. async 更优雅异步体验
- 3. Kotlin + 协程 + Retrofit + MVVM优雅的实现网络请求
- 4. 【思货】kotlin协程优雅的与Retrofit缠绵-正文
- 5. 【思货】kotlin协程优雅的与Retrofit缠绵-kotlin DSL简述
- 6. Retrofit+Rxjava网络层的优雅封装
- 7. retrofit-helper 简洁的封装retrofit，优雅的取消请求
- 8. RxHttp 优雅的实现请求串行与并行
- 9. Android OkHttp 史上最优雅的设置baseUrl
- 10. 优雅地使用Retrofit+RxJava(二)