共计 21729 个字符，预计需要花费 55 分钟才能阅读完成。
1、前言
始终有人问我，RxHttp 跟 Retrofit 相比有什么劣势？在这，我想通过稳定性、功能性、易用性几个方面来谈谈我的想法。
首先我申明一点，RxHttp 的呈现，并不是要干掉谁，而是给大家多一个抉择，多一个不一样的抉择。
稳定性
我始终认为 Retrofit，是当下综合得分最高的选手，RxHttp 也很优良，但得分比 Retrofit 低那么一丢丢，那这一丢丢差在哪里呢？就差在稳定性这一块，毕竟 Retrofit 是寰球出名的我的项目，github 上 37k+ star，稳定性必定不用说，反观 RxHttp，才 2.6k+ star，仅在国内小有名气。
稳定性不如 Retrofit，但不代表 RxHttp 就不稳固，截止 2020-12-27 日，RxHttp 在 github 上的提交已超过 1000 次，敞开的 issue 数量超过 200 个，公布的版本超过 40 个，尽管这些数据不能间接表明一个我的项目的稳定性，但也能作为一个参考，个人感觉，这对于一个仅开源 1.5 年的我的项目来说，曾经十分不错了，能够说，RxHttp 曾经十分稳固了，有问题我都会踊跃修复。
功能性
其实性能都实现，无非是实现的形式不一样而已，这个没什么好说的，已经看到过国内某某某网络框架，把 Retrofit 说的一无是处，说 Retrofit 这性能没有，那性能没有(实际上都有)，而后把本人的说的高大上，不晓得是不理解 Retrofit 还是成心这么干，在我看来，这种特意贬斥他人，抬高自己的行为，是无耻的。
易用性
在易用性，集体认为，RxHttp 就是神个别的存在，无论你是加密申请、上传、下载、进度监听、失败重试、动静 Baseurl、自定义解析器等等任意申请场景，皆遵循申请三部曲，只有记住申请三部曲，就把握了 RxHttp 精华，写申请代码就会熟能生巧，特地是对于新人来说，十分的敌对，能够疾速的上手。
反观 Retrofit，很多场景，咱们都须要再次封装能力更好的应用，比方，文件上传 / 下载 / 进度监听等等，而且 Retrofit 多达 20 几个注解，对新人来说着实不太敌对，对于新手，有时也会遗记某个注解是干嘛用的，再有就是多个注解非法在一起应用时，只有在编译期间能力给咱们明确的谬误，这也是我刚上手 Retrofit 比拟头疼的一点。
综上所述
RxHttp 易用性远胜 Retrofit，但稳定性不如 Retrofit，性能上都能实现，算打个平手。
RxHttp&RxLife 交换群（群号：378530627，常常会有技术交换，欢送进群）
本文仅介绍 RxHttp + 协程 的应用，更多功能请查看
RxHttp 让你眼前一亮的 Http 申请框架
RxHttp 完满适配 Android 10/11 上传 / 下载 / 进度监听
RxHttp 全网 Http 缓存最优解
gradle 依赖
1、必选
将 jitpack 增加到我的项目的 build.gradle 文件中，如下：
allprojects {
repositories {maven { url "https://jitpack.io"}
}
}注：RxHttp 2.6.0 版本起，已全面从 JCenter 迁徙至 jitpack
// 应用 kapt 依赖 rxhttp-compiler 时必须
apply plugin: 'kotlin-kapt'
android {
// 必须，java 8 或更高
compileOptions {
sourceCompatibility JavaVersion.VERSION_1_8
targetCompatibility JavaVersion.VERSION_1_8
}
}
dependencies {
implementation 'com.squareup.okhttp3:okhttp:4.9.1'
implementation 'com.github.liujingxing.rxhttp:rxhttp:2.7.3'
kapt 'com.github.liujingxing.rxhttp:rxhttp-compiler:2.7.3' // 生成 RxHttp 类，纯 Java 我的项目，请应用 annotationProcessor 代替 kapt
}2、可选
android {
kapt {
arguments {
// 依赖了 RxJava 时，rxhttp_rxjava 参数为必须，传入 RxJava 版本号
arg("rxhttp_rxjava", "3.1.1")
arg("rxhttp_package", "rxhttp") // 指定 RxHttp 类包名，非必须
}
}
// 如果我的项目未集成 kotlin，通过 javaCompileOptions 办法传参，在 defaultConfig 标签下
annotationProcessorOptions {
arguments = [
rxhttp_rxjava: '3.1.1',
rxhttp_package: 'rxhttp'
]
}
}
dependencies {//rxjava2 (RxJava2/Rxjava3 二选一，应用 asXxx 办法时必须)
implementation 'io.reactivex.rxjava2:rxjava:2.2.8'
implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'
implementation 'com.github.liujingxing.rxlife:rxlife-rxjava2:2.2.1' // 治理 RxJava2 生命周期，页面销毁，敞开申请
//rxjava3
implementation 'io.reactivex.rxjava3:rxjava:3.1.1'
implementation 'io.reactivex.rxjava3:rxandroid:3.0.0'
implementation 'com.github.liujingxing.rxlife:rxlife-rxjava3:2.2.1' // 治理 RxJava3 生命周期，页面销毁，敞开申请
// 非必须，依据本人需要抉择 RxHttp 默认内置了 GsonConverter
implementation 'com.github.liujingxing.rxhttp:converter-fastjson:2.7.3'
implementation 'com.github.liujingxing.rxhttp:converter-jackson:2.7.3'
implementation 'com.github.liujingxing.rxhttp:converter-moshi:2.7.3'
implementation 'com.github.liujingxing.rxhttp:converter-protobuf:2.7.3'
implementation 'com.github.liujingxing.rxhttp:converter-simplexml:2.7.3'
}如果你当初对协程还只知其一; 不知其二，没有关系，那是因为你还没有找到使用场景，而网络申请正是一个很好的切入场景，本文会教你如何优雅，并且平安的开启协程，以及用协程解决多任务，用着用着你就会了。
2、RxHttp 协程应用
2.1、申请三部曲
用过 RxHttp 的同学晓得，RxHttp 发送任意申请皆遵循申请三部曲，如下：
代码示意
//Kotlin 协程
val str = RxHttp.get("/service/...") // 第一步，确定申请形式，能够抉择 postForm、postJson 等办法
.toStr() // 第二步，确认返回类型，这里代表返回 String 类型
.await() // 第三步，应用 await 办法拿到返回值
//RxJava
RxHttp.get("/service/...") // 第一步，确定申请形式，能够抉择 postForm、postJson 等办法
.asString() // 第二步，应用 asXXX 系列办法确定返回类型
.subscribe(s -> { // 第三步, 订阅观察者
// 胜利回调
}, throwable -> {// 失败回调});注: await()是 suspend 挂断办法，须要在另一个 suspend 办法或协程环境中调用
协程申请三部曲详解
- 第一步，抉择
get、postForm、postJson等办法来确定申请形式，随后便可通过add、addFile、addHeader等办法来增加参数、文件、申请头等信息 - 第二步，调用
toXxx系列办法来确定返回类型，罕用的有toStr、toClass、toList，随后便可调用asFlow、retry、timeout、flowOn、filter、distinct、sort等 30 余个操作符来执行不同的业务逻辑，本文后续会一一介绍 - 第三步，最初，只需调用
await、tryAwait、awaitResult这三个中的任一操作符获取返回值即可，这一步，须要在协程环境中能力调用
接着，如果咱们要获取一个 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()办法是万能的，你能够传递任意数据类型过来
以上就是 RxHttp 在协程中最惯例的操作，把握申请三部曲，就把握了 RxHttp 的精华
2.2、BaseUrl 解决
RxHttp 通过 @DefaultDomain、@Domain 注解来配置默认域名及非默认域名，如下：
public class Url {
@DefaultDomain // 通过该注解设置默认域名
public static String BASE_URL = "https://www.wanandroid.com";
// name 参数在这会生成 setDomainToGoogleIfAbsent 办法，可随便指定名称
// className 参数在这会生成 RxGoogleHttp 类，可随便指定名称
@Domain(name = "Google", className = "Google")
public static String GOOGLE = "https://www.google.com";
}以上配置 www.wanandroid.com 为默认域名，www.google.com为非默认域名
多 BaseUrl 解决
// 应用默认域名发申请
RxHttp.get("/service/...")
.toSrt().await()
// 应用 google 域名形式一：传入的 url 间接带上 google 域名
RxHttp.get("https://wwww.google.com/service/...")
.toSrt().await()
// 应用 google 域名形式二：调用 setDomainToGoogleIfAbsent 办法
RxHttp.get("/service/...")
.setDomainToGoogleIfAbsent()
.toSrt().await()
// 应用 google 域名形式三：间接应用 RxGoogleHttp 类发送申请
RxGoogleHttp.get("/service/...")
.toSrt().await()留神：手动传入的域名优先级别最高，其次是调用 setDomainToXxx 办法，最初才会应用默认域名
动态域名解决
// 间接对 url 从新赋值即可，改完立刻失效
Url.BASE_URL = "https://www.baidu.com";
RxHttp.get("/service/...")
.toSrt().await()
// 此时申请的 url 为 https://www.baidu.com/service/...2.3、业务 code 对立判断
我想大部分人的接口返回格局都是这样的
class BaseResponse<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<BaseResponse<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 对象
.awaitResult {
val student = it
// 更新 UI
}.onFailure {
val msg = it.msg
val code = it.code
}能够看到，这里调用了 toResponse() 办法，就间接拿到了 data 字段，也就是 Student 对象。
此时，置信很多人会有疑难，
- 业务 code 哪里判断的？
- 异样回调里的
it是什么对象，为啥能够拿到msg、code字段？
先来答复第一个问题，业务 code 哪里判断的？
其实 toResponse() 办法并不是 RxHttp 外部提供的，而是用户通过自定义解析器，并用 @Parser 注解标注，最初由注解处理器 rxhttp-compiler 主动生成的，听不懂？没关系，间接看代码
@Parser(name = "Response")
open class ResponseParser<T> : TypeParser<T> {
// 以下两个构造方法是必须的
protected constructor() : super()
constructor(type: Type) : super(type)
@Throws(IOException::class)
override fun onParse(response: okhttp3.Response): T {val data: BaseResponse<T> = response.convertTo(BaseResponse::class, *types)
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，此时rxhttp-compiler 就会生成 toResponse<T>() 办法，命名规定为to{name}
第二点，咱们在 if 语句里，code != 200或 data == null 时，就抛出 ParseException 异样，并带上了 msg、code 字段，所以咱们在异样回调通过强转，就能够拿到这两个字段
接着答复第二个问题，异样回调里的 it 是什么对象，为啥能够拿到 msg、code 字段？
其实 it 就是 Throwable 对象，而 msg、code 是Throwable的扩大字段，这须要咱们本人为其扩大，代码如下：
val Throwable.code: Int
get() =
when (this) {
is HttpStatusCodeException -> this.statusCode //Http 状态码异样
is ParseException -> this.errorCode.toIntOrNull() ?: -1 // 业务 code 异样
else -> -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.4、操作符介绍
awaitResult 返回 kotlin.Result
awaitResult是最罕用的字符，它能够解决申请胜利 / 失败回调，如下：
val result: Result<Student> = RxHttp
.postForm("/service/...")
.toClass<Student>()
.awaitResult {// 申请胜利，通过 it 拿到 Student 对象}.onFailure {// 申请异样，通过 it 拿到 Throwable 对象} 拿到 kotlin.Result 对象后，随后胜利 / 失败解决相干逻辑
tryAwait 异样返回 null
tryAwait会在异样呈现时，返回 null，如下：
val student = RxHttp.postForm("/service/...")
.toResponse<Student>()
.timeout(100) // 超时时长为 100 毫秒
.tryAwait() // 这里返回 Student? 对象，如果出现异常，那它就是 null 当然，tryAwait也反对异样回调，如下
val student = RxHttp.postForm("/service/...")
.toResponse<Student>()
.timeout(100) // 超时时长为 100 毫秒
.tryAwait { // 同样的，出现异常，返回 null
// 这里通过 it 拿到 Throwable 对象
} 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()repeat 轮训申请
repeat操作符共有 3 个参数，如下：
/**
* @param times 轮训次数，默认 Long.MAX_VALUE，即始终轮训
* @param period 轮训周期，默认 0
* @param stop 轮训终止条件，默认 false，即无条件轮训 times 次
*/
fun <T> IAwait<T>.repeat(
times: Long = Long.MAX_VALUE,
period: Long = 0,
stop: suspend (T) -> Boolean = {false}
)以上 3 个参数可随便搭配应用，用法如下：
val student = RxHttp.postForm("/service/...")
.toResponse<Student>()
.repeat(10, 1000) { // 轮训 10 次，每次距离 1s
return it.id == 8888 // 如果学生 id 是 8888，则进行轮训
}
.await() retry 失败重试
retry操作符共有 3 个参数，别离是重试次数、重试周期、重试条件，如下：
/**
* 失败重试，该办法仅在应用协程时才无效
* @param times 重试次数, 默认 Int.MAX_VALUE 代表一直重试
* @param period 重试周期, 默认为 0, 单位: milliseconds
* @param test 重试条件, 默认为 true，只有出现异常就重试
*/
fun retry(
times: Int = Int.MAX_VALUE,
period: Long = 0,
test: suspend (Throwable) -> Boolean = {true}
)3 个参数可随便搭配应用，咱们须要在网络出现异常时，重试 2 次，每次距离 1 秒，代码如下：
val student = RxHttp.postForm("/service/...")
.toResponse<Student>()
.retry(2, 1000) { // 重试 2 次，每次距离 1s
it is ConnectException // 如果是网络异样就重试
}
.await() timeout 超时
OkHttp 提供了全局的读、写及连贯超时，有时咱们也须要为某个申请设置不同的超时时长，此时就能够用到 RxHttp 的 timeout(Long) 办法，如下：
val student = RxHttp.postForm("/service/...")
.toResponse<Student>()
.timeout(3000) // 超时时长为 3s
.await() map 转换符号
map操作符很好了解，RxJava 及协程的 Flow 都有该操作符，性能都是一样，用于转换对象，如下：
val student = RxHttp.postForm("/service/...")
.toStr()
.map {it.length} //String 转 Int
.tryAwait() // 这里返回 Student? 对象，即有可能为空 filter 过滤操作
如果服务器返回列表数据，则咱们可对列表进行过滤操作，如下：
val students = RxHttp.postForm("/service/...")
.toList<Student>()
.filter{it.age > 20} // 过滤年龄大于 20 岁的学生
.await() 还能够选用 filterTo 操作符，将过滤后的数据增加到指定列表中，如下：
val list = mutableListOf<Student>()
val students = RxHttp.postForm("/service/...")
.toList<Student>()
.filterTo(list){it.age > 20} // 过滤年龄大于 20 岁的学生
.await() // 此时返回的列表对象就是咱们传入的列表对象distinct 去重
该操作符能够对服务器返回的列表，做去重操作，如下：
// 依据 Student 对象的 hashCode 去重
val students = RxHttp.postForm("/service/...")
.toList<Student>()
.distinct()
.await()
// 依据 Student 对象的 id 去重
val students = RxHttp.postForm("/service/...")
.toList<Student>()
.distinctBy {it.id}
.await()
// 将去重后的数据增加到指定列表中，并且去重时，会对指定列表数据做判断
val list = mutableListOf<Student>()
val students = RxHttp.postForm("/service/...")
.toList<Student>()
.distinctTo(list) {it.id}
.await() sort 排序
排序有 sortXxx、sortedXxx 两大类型操作符，区别在于 sortXxx 在列表内排序，排序完，返回本身，而 sortedXxx 在列表外排序，排序完，返回新的列表，这里只对 sortXxx 介绍，如下：
// 依据 id 程序排序
val students = RxHttp.postForm("/service/...")
.toList<Student>()
.sortBy {it.id}
.await()
// 依据 id、age 两个字段程序排序，id 优先，其次 age
val students = RxHttp.postForm("/service/...")
.toList<Student>()
.sortBy({it.id}, {it.age})
.await()
// 返回两个排序对象，自行实现排序规定
val students = RxHttp.postForm("/service/...")
.toList<Student>()
.sortWith { student1, student2 ->
student1.id.compareTo(student2.id)
}
.await() flowOn 指定上游所在线程
该操作符跟 Flow 外面的 flowOn 操作符一样，用于指定上游所在线程，如下：
val students = RxHttp.postForm("/service/...")
.toList<Student>()
.sortBy {it.id} //IO 线程执行
.flowOn(Dispatchers.IO)
.distinctBy {it.id} //Default 线程执行
.flowOn(Dispatchers.Default)
.filter{it.age > 20} //IO 线程执行
.flowOn(Dispatchers.IO)
.flowOn(Dispatchers.Default)
.await() asFlow 转 Flow 对象
如果你喜爱 kotlin 的 flow 流，那么asFlow 就派上用场了，如下：
RxHttp.postForm("/service/...")
.toList<Student>()
.asFlow()
.collect {// 这里拿到 List<Student> 对象} 留神：应用 asFlow 操作符后，须要应用 collect 代替 await 操作符
subList、take 截取列表
subList用于截取某段列表，截取范畴越界，则抛出越界异样；take用于从 0 开始，取 n 个数据，有余 n 个时，返回全副，如下：
val students = RxHttp.postForm("/service/...")
.toList<Student>()
.subList(1，10) // 截取 9 个数据
.take(5) // 从 9 个中取前 5 个
.await() async 异步操作
如果咱们由两个申请须要并行时，就能够应用该操作符，如下：
// 同时获取两个学生信息
suspend void initData() {val asyncStudent1 = RxHttp.postForm("/service/...")
.toResponse<Student>()
.async(this) //this 为 CoroutineScope 对象，这里会返回 Deferred<Student>
val asyncStudent2 = RxHttp.postForm("/service/...")
.toResponse<Student>()
.async(this) //this 为 CoroutineScope 对象，这里会返回 Deferred<Student>
// 随后调用 await 办法获取对象
val student1 = asyncStudent1.await()
val student2 = asyncStudent2.await()} 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() 自定义操作符
RxHttp 内置了一系列弱小又好用的操作符，然而必定满足不了所有的业务场景，此时咱们就能够思考自定义操作符
自定义 takeLast 操作符
如咱们有这样一个需要，自定义须要在列表尾部取 n 条数据，有余 n 条，返回全副
后面咱们介绍了 take 操作符，它是从 0 开始，取 n 条数据，如果有余 n 条，则全副返回，来看看源码
fun <T> IAwait<out Iterable<T>>.take(count: Int): IAwait<List<T>> = newAwait {await().take(count)
}代码解读，
1、IAwait是一个接口，如下：
interface IAwait<T> {suspend fun await(): T
}该接口仅有一个 await() 办法，返回申明的T
2、newAwait操作符，只是创立了一个 IAwait 接口的实现而已，如下：
inline fun <T, R> IAwait<T>.newAwait(crossinline block: suspend IAwait<T>.() -> R
): IAwait<R> = object : IAwait<R> {override suspend fun await(): R {return this@newAwait.block()
}
}3、因为咱们是为 IAwait<out Iterable<T>> 对象扩大的 take 办法，故在外部，咱们调用 await() 办法它返回 Iterable<T> 对象，最初就执行 Iterable<T> 对象的扩大办法 take(Int) 获取从 0 开是的 n 条数据，take(Int)是零碎提供的办法，源码如下：
public fun <T> Iterable<T>.take(n: Int): List<T> {require(n >= 0) {"Requested element count $n is less than zero."}
if (n == 0) return emptyList()
if (this is Collection<T>) {if (n >= size) return toList()
if (n == 1) return listOf(first())
}
var count = 0
val list = ArrayList<T>(n)
for (item in this) {list.add(item)
if (++count == n)
break
}
return list.optimizeReadOnlyList()}ok，回到后面的话题，如何自定义一个操作，实现在列表尾部取 n 条数据，有余 n 条，返回全副
看了下面的 take(int) 源码，咱们就能够很轻松的写出如下代码：
fun <T> IAwait<out List<T>>.takeLast(count: Int): IAwait<List<T>> = newAwait {await().takeLast(count)
}首先，咱们对 IAwait<out List<T>> 扩大了 takeLast(Int) 办法，随后调用 newAwait 创立了 IAwait 接口的实例对象，接着调用 await() 办法返回 List<T> 对象，最初调用零碎为 List<T> 扩大的 takeLast(Int) 办法
定义好了，咱们就可间接应用，如下：
val students = RxHttp.postForm("/service/...")
.toList<Student>()
.takeLast(5) // 取列表尾部 5 条数据，有余时，全副返回
.await() 以上操作符随便搭配
以上操作符，可随便搭配应用，但调用程序的不同，产生的成果也不一样，这里先通知大家，以上操作符仅会对上游代码产生影响。
如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")) // 增加单个文件
.addFiles("fileList", ArrayList<File>()) // 增加多个文件
.toResponse<String>()
.await() 只须要通过 addFile 系列办法增加 File 对象即可，就是这么简略粗犷，想监听上传进度，须要调用 toFlow 办法，并传入进度回调即可，如下：
RxHttp.postForm("/service/...")
.addFile("file", File("xxx/1.png"))
.addFiles("fileList", ArrayList<File>())
.toFlow<String> { // 这里还能够抉择自定义解析器对应的 toFlowXxx 办法
val process = it.progress // 已上传进度 0-100
val currentSize = it.currentSize // 已上传 size，单位：byte
val totalSize = it.totalSize // 要上传的总 size 单位：byte
}.catch {// 异样回调}.collect {// 胜利回调}3.2、文件下载
接着再来看看下载，间接贴代码
val localPath = "sdcard//android/data/..../1.apk"
val path = RxHttp.get("/service/...")
.toDownload(localPath) // 下载须要传入本地文件门路
.await() // 返回本地存储门路，这里也就是 localPath下载调用 toDownload(String) 办法，传入本地文件门路即可，要监听下载进度？也简略，如下：
val localPath = "sdcard//android/data/..../1.apk"
val path = RxHttp.get("/service/...")
.toDownload(localPath) {
//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 append 是否追加下载，即是否断点下载
* @param capacity 队列 size，仅监听进度回调时失效
* @param progress 进度回调
*/
fun CallFactory.toDownload(
destPath: String,
append: Boolean = false,
capacity: Int = 1,
progress: (suspend (Progress) -> Unit)? = null
): Await<String>如果你须要断点下载，只须要 append 传true就可，如下：
val localPath = "sdcard//android/data/..../1.apk"
val path = RxHttp.get("/service/...")
.toDownload(localPath, true) {
//it 为 Progress 对象
val process = it.progress // 已下载进度 0-100
val currentSize = it.currentSize // 已下 size，单位：byte
val totalSize = it.totalSize // 要下的总 size 单位：byte
}
.await()到这，RxHttp 协程的根底 Api 根本介绍结束，那么问题了，以上介绍的 Api 都依赖与协程环境，那我这么开启协程呢？亦或者说，我对协程不是很懂，你只有保障平安的前提下，通知怎么用就行了，ok，那上面如何平安的开启一个协程，做到主动异样捕捉，且页面销毁时，主动敞开协程及申请
4、协程开启及敞开
对于协程的开启，Jetpack 库里提供了 lifecycle-runtime-ktx、lifecycle-viewmodel-ktx 这两个框架，能够十分不便的开启协程，并在页面销毁时主动敞开协程，如下：
// FragmentActivity、Fragment 环境
lifecycleScope.launch {RxHttp.get("/server/...")
.toClass<Student>()
.awaitResult {// 申请胜利，通过 it 拿到 Student 对象}.onFailure {// 申请异样，通过 it 拿到 Throwable 对象}
}
// ViewModel 环境
viewModelScope.launch {RxHttp.get("/server/...")
.toClass<Student>()
.awaitResult {// 申请胜利，通过 it 拿到 Student 对象}.onFailure {// 申请异样，通过 it 拿到 Throwable 对象}
} 如果想手动敞开，拿到 launch 办法返回的 Job 对象，通过该对象能够敞开协程，协程敞开，申请就会自定敞开，如下：
//ViewModel 环境
val job = lifecycleScope.launch {RxHttp.get("/server/...")
.toClass<Student>()
.awaitResult {// 申请胜利，通过 it 拿到 Student 对象}.onFailure {// 申请异样，通过 it 拿到 Throwable 对象}
}
// 在适合的机会敞开协程
job.cancel()5、协程多任务处理
咱们晓得，协程最大的劣势就是：能以看起来同步的代码，写出异步的逻辑，这使得咱们能够十分优雅的实现多任务场景，比方多申请的并行 / 串行
5.1、协程串行多个申请
假如，咱们有这么一种场景，首先获取 Student 对象，随后通过 studentId 获取学生的家庭成员列表，后者依赖于前者，这是典型的串行场景
看看通过协程如何解决这个问题，如下：
class MainActivity : AppCompatActivity() {override fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState);
// 启动协程，发送申请
lifecycleScope.launch {sendRequest() }
}
suspend fun sendRequest() {
// 获取 student 对象，null 的话，间接返回
val student = getStudent() ?: return
// 通过学生 Id，查问家庭成员信息
val personList = getFamilyPersons(student.id)
// 拿到相干信息后，便可间接更新 UI，如：tvName.text = student.name
}
// 挂断办法，获取学生信息
suspend fun getStudent(): Student? {return RxHttp.get("/service/...")
.add("key", "value")
.addHeader("headKey", "headValue")
.toClass<Student>()
.tryAwait() //tryAwait，出现异常时，返回 null}
// 挂断办法，获取家庭成员信息
suspend fun getFamilyPersons(studentId: Int): List<Person> {return RxHttp.get("/service/...")
.add("studentId", "10000")
.toClass<List<Person>>()
.onErrorReturnItem(ArrayList()) // 出现异常时，返回空的 List
.await()}
}咱们重点看下协程代码块，首先通过第一个申请拿到 Student 对象，随后拿到 studentId，发送第二个申请获取学习家庭成员列表，拿到后，便能够间接更新 UI，怎么样，是不是看起来同步的代码，写出了异步的逻辑。
串行申请中，只有其中一个申请出现异常，协程便会敞开（同时也会敞开申请），进行执行剩下的代码，接着走异样回调
5.2、协程并行多个申请
申请并行，在事实开发中，也是粗茶淡饭，在一个 Activity 中，咱们往往须要拿到多种数据来展现给用户，而这些数据，都是不同接口下发的。
如咱们有这样一个页面，顶部是横向滚动的 Banner 条，Banner 条上面展现学习列表，此时就有两个接口，一个获取 Banner 条列表，一个获取学习列表，它们两个互不依赖，便能够并行执行，如下：
class MainActivity : AppCompatActivity() {override fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState);
// 启动协程，发送申请
lifecycleScope.launch {sendRequest(this) }
}
// 以后在 UI 线程运行
suspend fun sendRequest(scope: CoroutineScope) {val asyncBanner = getBanners(scope) // 这里返回 Deferred<List<Banner>> 对象
val asyncPersons = getStudents(scope) // 这里返回 Deferred<List<Student>> 对象
val banners = asyncBanner.tryAwait() // 这里返回 List<Banner>? 对象
val students = asyncPersons.tryAwait() // 这里返回 List<Student>? 对象
// 开始更新 UI
}
// 挂断办法，获取学生信息
suspend fun getBanners(scope: CoroutineScope): Deferred<List<Banner>> {return RxHttp.get("/service/...")
.add("key", "value")
.addHeader("headKey", "headValue")
.toClass<List<Banner>>()
.async(scope) // 留神这里应用 async 异步操作符
}
// 挂断办法，获取家庭成员信息
suspend fun getStudents(scope: CoroutineScope): Deferred<List<Student>> {return RxHttp.get("/service/...")
.add("key", "value")
.toClass<List<Student>>()
.async(scope) // 留神这里应用 async 异步操作符
}
}在上述代码的两个挂断办法中，均应用了 async 异步操作符，此时这两个申请就并行发送申请，随后拿到 Deferred<T> 对象，调用其 await() 办法，最终拿到 Banner 列表及 Student 列表，最初便能够间接更新 UI。
划重点
并行跟串行一样，如果其中一个申请呈现了异样，协程便会主动敞开（同时敞开申请），进行执行剩下的代码，接着走异样回调。如果想多个申请互不影响，就能够应用下面介绍的 onErrorReturn、onErrorReturnItem 操作符，出现异常时，给出一个默认对象，又或者应用 tryAwait 操作符获取返回值，出现异常时，返回 null，这样就不会影响其它申请的执行。
6、原理分析
RxHttp 应用到当下风行的注解处理器工具 (Annotation Processing Tool，以下简称 APT)，像出名的Eventbus、ButterKnife、Dagger2、Glide 以及 Jetpack 库里十分好用 Room 数据库框架，都应用到了 APT，它可能在编译时检索注解信息，通过 Javapoet 框架生成 Java 类、办法等相干代码(想生成 Kotlin 相干代码，应用kotlinpoet)，并因而在运行时做到零性能损耗。
那么，APT 给 RxHttp 带来了哪些劣势？RxHttp 又是如何应用 APT 的？持续往下看
说起 APT，大家脑海里第一个想到的可能是解耦，没错，解耦是它的一大劣势，其实它还有一个更大有劣势，那就是依据配置，生成不同的代码逻辑；比方在 RxHttp 中，默认是不依赖 RxJava 的，然而如果你须要应用 RxHttp + RxJava 形式发送申请，就能够在 annotationProcessorOptions 标签中的 rxhttp_rxjava 参数来配置 RxJava 大版本，可传入 RxJava2 或RxJava3，外部依据传入的 RxJava 版本，生成不同的代码，这样就可做到一套代码同时兼通 RxJava2 和RxJava3，如果后续出了 RxJava4、RxJava5 等新版本，一样能够兼容，而且非常简单。
在 RxHttp v2.4.2 以下版本中，对 OkHttp 的兼容，也应用了该形式去适配 okhttp 各个版本，为此，RxHttp 适配了 OkHttp v3.12.0到 v4.9.0(截止 2020/12/27 最新版本) 中的任一版本(v4.3.0 除外，该版本有一个 bug，导致无奈适配)，因而，应用RxHttp，齐全不必放心 okhttp 版本抵触问题。
同时兼容 RxJava、OkHttp 不同版本，这就是 APT 带给 RxHttp 的第一大劣势。
RxHttp 是如何应用 APT？在 RxHttp 中，一共定义了 6 个注解，如下：
- @DefaultDomain：用它来指定默认的 baseUrl，只能应用一次
- @Domain：指定非默认的 baseUrl，可应用屡次
- @Parser：指定自定义的解析器，可应用屡次，这个十分弱小，可在解析器里写本人数据解析逻辑，并返回任意类型的数据，完满解决服务端返回的数据不标准问题
- @Param：指定自定义的 Param，可应用屡次，发送对立加密申请时用到
- @OkClient：为不同申请配置不同的 OkHttpClient 对象，可屡次应用
- @Converter：为不同申请配置不同的 Converter 对象，可屡次应用
RxHttp 的注解处理器是 rxhttp-compiler，它首要任务就是生成 RxHttp 类，其次就是检索以上 6 个注解，生成对应的类及办法，这就使得，无论咱们如何去自定义，写申请代码时，始终遵循申请三部曲，如咱们要发送对立加密的申请，就能够间接应用@Param 注解生成的办法，如下：
// 发送加密的 post 表单申请，办法名可通过 @Param 注解随便指定
val student = RxHttp.postEncryptForm("/service/...")
.add("key", "value")
.toClass<Student>()
.await()其它 5 个注解带来的劣势就不一一介绍了，总之就是另一大劣势，解耦，使得任意申请，皆遵循申请三部曲
RxHttp 工作流程
接下来，讲讲 RxHttp 的工作流程，有 5 个重要的角色，别离是：
- RxHttp：这是最重要的一个角色，所以申请的惟一入口，外部持有一个 Param 对象，它的职责是，申请参数 / 申请头 /BaseUrl 的解决，申请线程的调度，提供注解生成的办法等等，最终的使命就是通过 Param 构建一个
okhttp3.Request对象，随后在构建一个okhttp3.Call对象，并把 Call 对象丢给Observable或IAwait，而后由Observable或IAwait真正的去执行申请 - Param：它的职责是解决申请参数 / 申请头 /url 等所有用来构建
okhttp3.Request须要的货色，最终使命就是构建okhttp3.Request对象，它被 RxHttp 类所持有，RxHttp 把构建okhttp3.Request对象所须要的货色，都交给 Param 去实现的 - IAwiat：联合协程发申请时，真正执行网络申请的对象，具体实现类为
AwaitImpl, 它外部持有Parser对象，申请返回后，将okhttp3.Response丢给Parser去解析，并返回解析后的对象 - Observable：联合 RxJava 发送申请时，真正执行网络申请的对象，具体实现类有
ObservableCallExecute、ObservableCallEnqueue、ObservableParser，别离用于同步申请、异步申请及申请返回后对okhttp3.Response对象的数据解析，ObservableParser外部持有Parser对象，具体的解析工作都交给Parser - Parser：负责数据解析工作，将数据解析成咱们想要的数据类型，这是一个接口对象，外部只有
onParse(response: Response): T这一个办法，具体实现类有 4 个：SimpleParser、StreamParser、SuspendStreamParser、BitmapParser，第一个为万能的解析器，外部的asClass/toClss办法，就是通过它去实现的；第二第三是下载文件时用的的解析器，区别前者是联合 RxJava 下载的，后者是联合协程下载的；最初一个是解析Bitmap对象用的，asBitmap/toBitmap就是通过它去实现的
工作流程图如下：
相干学习视频举荐：
【2021 最新版】Android studio 装置教程 +Android（安卓）零基础教程视频（适宜 Android 0 根底，Android 初学入门）含音视频 哔哩哔哩bilibili
音视频（NDK）开发入门系列教程附：《Android 音视频开发进阶指南》哔哩哔哩bilibili
Android 进阶零碎学习——Gradle 入门与我的项目实战 哔哩哔哩bilibili
Android 开源架构原理剖析与手写实战——组件化原理解析！哔哩哔哩bilibili