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
发表回复