欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  移动技术

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

程序员文章站 2022-07-02 08:15:56
1、前言 Hello,各位小伙伴,又见面了,回首过去, "RxHttp" 就要迎来一周年生日了(19年4月推出),这一年,走过来真心....真心不容易,代码维护、写文章、写文档等等,经常都是干到零点之后,也是我首次花费大部分业余时间来维护一个开源项目,全程一个人维护,要知道,网络请求库不同于其它开源 ......

1、前言

 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 ,比Retrofit 更优雅的协程体验

代码表示

rxhttp.get("/service/...") //第一步,确定请求方式,可以选择postform、postjson等方法
    .asstring()            //第二步,使用asxxx系列方法确定返回类型
    .subscribe(s -> {      //第三步, 订阅观察者
        //成功回调
    }, throwable -> {
        //失败回调
    });

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

RxHttp ,比Retrofit 更优雅的协程体验
代码表示

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.codeit.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()                       

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

但如果timeoutretry互换下位置,就不一样了,如下:

val student = rxhttp.postform("/service/...")
    .toresponse<student>()
    .retry(2, 1000) { it is timeoutcancellationexception }       
    .timeout(50)                                  
    .await()                       

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

在看timeoutstartdelay操作符

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

可以看到,我们为viewmodellifecycleowner都扩展了一个名为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。

划重点

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

6、总结

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

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

rxhttp 让你眼前一亮的http请求框架

rxhttp 全网http缓存最优解 

转自:https://www.cnblogs.com/liujingxing/p/12741525.html