led发光二极管,四川省安全生产监督管理局,青木原森林
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上手
本文只介绍rxhttp与协程相关的部分，如果你之前没有了解过rxhttp，建议先阅读rxhttp 让你眼前一亮的http请求框架一文
如果你现在对协程还一知半解，没有关系，那是因为你还没有找到运用场景，而网络请求正是一个很好的切入场景，本文会教你如何优雅，并且安全的开启协程，以及用协程处理多任务，用着用着你就会了。
用过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在协程中最常规的操作，接下来，上真正的干货
我想大部分人的接口返回格式都是这样的
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语句的判断条件即可
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()
okhttp提供了全局的读、写及连接超时，有时我们也需要为某个请求设置不同的超时时长，此时就可以用到rxhttp的timeout(long)方法，如下：
val student = rxhttp.postform("/service/...")
.toresponse<student>()
.timeout(3000) //超时时长为3s
.await()
如果我们由两个请求需要并行时，就可以使用该操作符，如下：
//同时获取两个学生信息
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()
}
delay操作符是请求结束后，延迟一段时间返回；而startdelay操作符则是延迟一段时间后再发送请求，如下：
val student = rxhttp.postform("/service/...")
.toresponse<student>()
.delay(1000) //请求回来后，延迟1s返回
.await()
val student = rxhttp.postform("/service/...")
.toresponse<student>()
.startdelay(1000) //延迟1s后再发送请求
.await()
有些情况，我们不希望请求出现异常时，直接走异常回调，此时我们就可以通过两个操作符，给出默认的值，如下：
//根据异常给出默认值
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()
如果你不想在异常时返回默认值，又不想异常是影响程序的执行，tryawait就派上用场了，它会在异常出现时，返回null，如下：
val student = rxhttp.postform("/service/...")
.toresponse<student>()
.timeout(100) //超时时长为100毫秒
.tryawait() //这里返回 student? 对象，即有可能为空
map操作符很好理解，rxjava即协程的flow都有该操作符，功能都是一样，用于转换对象，如下：
val student = rxhttp.postform("/service/...")
.tostr()
.map { it.length } //string转int
.tryawait() //这里返回 student? 对象，即有可能为空
以上操作符，可随意搭配使用，但调用顺序的不同，产生的效果也不一样，这里先告诉大家，以上操作符只会对上游代码产生影响。
如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对文件的优雅操作是与生俱来的，在协程的环境下，依然如此，没有什么比代码更具有说服力，直接上代码
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
接着再来看看下载，直接贴代码
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对象，我们需要通过该对象手动关闭协程。其它就没啥区别了。
我们知道，协程最大的优势就是：能以看起来同步的代码，写出异步的逻辑，这使得我们可以非常优雅的实现多任务场景，比如多请求的并行/串行
假设，我们有这么一种场景，首先获取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，怎么样，是不是看起来同步的代码，写出了异步的逻辑。
串行请求中，只要其中一个请求出现异常，协程便会关闭（同时也会关闭请求），停止执行剩下的代码，接着走异常回调
请求并行，在现实开发中，也是家常便饭，在一个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的处理、公共参数/请求头的添加、请求加解密、缓存等等，请查看
转自：https://www.cnblogs.com/liujingxing/p/12741525.html
如对本文有疑问，请在下面进行留言讨论，广大热心网友会与你互动！！ 点击进行留言回复
Android Manifest中meta-data扩展元素数据的配置与获取方式
Android实现获取meta-data和build.gradle的值
Android获取清单文件中的meta-data,解决碰到数值为null的问题
解决webview 第二次调用loadUrl页面不刷新的问题
解决Android WebView拦截url,视频播放加载失败的问题
Android webview加载https链接错误或无响应的解决
网友评论