乐趣区

关于android:RxHttp-比Retrofit-更优雅的协程体验

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 != 200data == null 时,就抛出 ParseException 异样,并带上了 msg、code 字段,所以咱们在异样回调通过强转,就能够拿到这两个字段

接着答复第二个问题,异样回调里的 it 是什么对象,为啥能够拿到 msg、code 字段?

其实 it 就是 Throwable 对象,而 msg、codeThrowable的扩大字段,这须要咱们本人为其扩大,代码如下:

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

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

但如果 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"))        // 增加单个文件   
     .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>

如果你须要断点下载,只须要 appendtrue就可,如下:

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-ktxlifecycle-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。

划重点

并行跟串行一样,如果其中一个申请呈现了异样,协程便会主动敞开(同时敞开申请),进行执行剩下的代码,接着走异样回调。如果想多个申请互不影响,就能够应用下面介绍的 onErrorReturnonErrorReturnItem 操作符,出现异常时,给出一个默认对象,又或者应用 tryAwait 操作符获取返回值,出现异常时,返回 null,这样就不会影响其它申请的执行。

6、原理分析

RxHttp 应用到当下风行的注解处理器工具 (Annotation Processing Tool,以下简称 APT),像出名的EventbusButterKnifeDagger2Glide 以及 Jetpack 库里十分好用 Room 数据库框架,都应用到了 APT,它可能在编译时检索注解信息,通过 Javapoet 框架生成 Java 类、办法等相干代码(想生成 Kotlin 相干代码,应用kotlinpoet),并因而在运行时做到零性能损耗。

那么,APT 给 RxHttp 带来了哪些劣势?RxHttp 又是如何应用 APT 的?持续往下看

说起 APT,大家脑海里第一个想到的可能是解耦,没错,解耦是它的一大劣势,其实它还有一个更大有劣势,那就是依据配置,生成不同的代码逻辑;比方在 RxHttp 中,默认是不依赖 RxJava 的,然而如果你须要应用 RxHttp + RxJava 形式发送申请,就能够在 annotationProcessorOptions 标签中的 rxhttp_rxjava 参数来配置 RxJava 大版本,可传入 RxJava2RxJava3,外部依据传入的 RxJava 版本,生成不同的代码,这样就可做到一套代码同时兼通 RxJava2RxJava3,如果后续出了 RxJava4RxJava5 等新版本,一样能够兼容,而且非常简单。

RxHttp v2.4.2 以下版本中,对 OkHttp 的兼容,也应用了该形式去适配 okhttp 各个版本,为此,RxHttp 适配了 OkHttp v3.12.0v4.9.0(截止 2020/12/27 最新版本) 中的任一版本(v4.3.0 除外,该版本有一个 bug,导致无奈适配),因而,应用RxHttp,齐全不必放心 okhttp 版本抵触问题。

同时兼容 RxJavaOkHttp 不同版本,这就是 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 对象丢给 ObservableIAwait,而后由 ObservableIAwait真正的去执行申请
  • Param:它的职责是解决申请参数 / 申请头 /url 等所有用来构建 okhttp3.Request 须要的货色,最终使命就是构建 okhttp3.Request 对象,它被 RxHttp 类所持有,RxHttp 把构建 okhttp3.Request 对象所须要的货色,都交给 Param 去实现的
  • IAwiat:联合协程发申请时,真正执行网络申请的对象,具体实现类为 AwaitImpl, 它外部持有Parser 对象,申请返回后,将 okhttp3.Response 丢给 Parser 去解析,并返回解析后的对象
  • Observable:联合 RxJava 发送申请时,真正执行网络申请的对象,具体实现类有 ObservableCallExecuteObservableCallEnqueueObservableParser,别离用于同步申请、异步申请及申请返回后对okhttp3.Response 对象的数据解析,ObservableParser外部持有 Parser 对象,具体的解析工作都交给Parser
  • Parser:负责数据解析工作,将数据解析成咱们想要的数据类型,这是一个接口对象,外部只有 onParse(response: Response): T 这一个办法,具体实现类有 4 个:SimpleParserStreamParserSuspendStreamParserBitmapParser,第一个为万能的解析器,外部的 asClass/toClss 办法,就是通过它去实现的;第二第三是下载文件时用的的解析器,区别前者是联合 RxJava 下载的,后者是联合协程下载的;最初一个是解析 Bitmap 对象用的,asBitmap/toBitmap就是通过它去实现的

工作流程图如下:

相干学习视频举荐:

【2021 最新版】Android studio 装置教程 +Android(安卓)零基础教程视频(适宜 Android 0 根底,Android 初学入门)含音视频 哔哩哔哩bilibili

音视频(NDK)开发入门系列教程附:《Android 音视频开发进阶指南》哔哩哔哩bilibili

Android 进阶零碎学习——Gradle 入门与我的项目实战 哔哩哔哩bilibili

Android 开源架构原理剖析与手写实战——组件化原理解析!哔哩哔哩bilibili

退出移动版