RxHttp ，比Retrofit 更優雅的協程體驗
一、前言
Hello，各位小夥伴，又見面了，回首過去，RxHttp 就要迎來一週年生日了(19年4月推出)，這一年，走過來真心....真心不容易，代碼維護、寫文章、寫文檔等等，常常都是幹到零點以後，也是我首次花費大部分業餘時間來維護一個開源項目，全程一我的維護，要知道，網絡請求庫不一樣於其它開源項目，各位同僚對這類項目的要求都很是高，並且前面有一座大山Retrofit，如何在這種狀況下，殺出重圍？那就只有死磕細節，作到人無我有，人有我精。java
幸運的是，RxHttp它作到了，截止本文發表，在Github上，已達到1600+star，在RxHttp$RxLife交流羣（羣號：378530627，常常會有技術交流，歡迎進羣）也有了300+人，此次，RxHttp 更新到了2.x版本，給你們帶來不同的協程體驗，爲啥不同？看完本文你會有答案android
gradle依賴git
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類github
RxHttp2.2.0版本起，已徹底剔除了RxJava，採用外掛的方法替代，支持RxJava二、RxJava3，詳情查看RxHttp上手json
遇到問題，點這裏，點這裏，點這裏，99%的問題都能本身解決緩存
本文只介紹RxHttp與協程相關的部分，若是你以前沒有了解過RxHttp，建議先閱讀RxHttp 讓你眼前一亮的Http請求框架一文安全
若是你如今對協程還只知其一;不知其二，沒有關係，那是由於你尚未找到運用場景，而網絡請求正是一個很好的切入場景，本文會教你如何優雅，而且安全的開啓協程，以及用協程處理多任務，用着用着你就會了。網絡
二、RxHttp 協程使用
用過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在協程中最常規的操做，接下來，上真正的乾貨
2.一、業務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.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語句的判斷條件便可
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.三、timeout 超時
OkHttp提供了全局的讀、寫及鏈接超時，有時咱們也須要爲某個請求設置不一樣的超時時長，此時就能夠用到RxHttp的timeout(Long)方法，以下：
val student = RxHttp.postForm("/service/...")
.toResponse<Student>()
.timeout(3000) //超時時長爲3s
.await()
2.四、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.五、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.六、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.七、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.九、以上操做符隨意搭配
以上操做符，可隨意搭配使用，但調用順序的不一樣，產生的效果也不同，這裏先告訴你們，以上操做符只會對上游代碼產生影響。
如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對文件的優雅操做是與生俱來的，在協程的環境下，依然如此，沒有什麼比代碼更具備說服力，直接上代碼
3.一、文件上傳
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.二、文件下載
接着再來看看下載，直接貼代碼
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對象，咱們須要經過該對象手動關閉協程。其它就沒啥區別了。
五、協程多任務處理
咱們知道，協程最大的優點就是：能以看起來同步的代碼，寫出異步的邏輯，這使得咱們能夠很是優雅的實現多任務場景，好比多請求的並行/串行
5.一、協程串行多個請求
假設，咱們有這麼一種場景，首先獲取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.二、協程並行多個請求
請求並行，在現實開發中，也是屢見不鮮，在一個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的處理、公共參數/請求頭的添加、請求加解密、緩存等等，請查看
最後，開源不易，寫文章更不易，還須要勞煩你們給本文點個贊，能夠的話，再給個star，感受不盡，🙏🙏🙏🙏🙏🙏🙏🙏🙏🙏🙏🙏
- 1. Retrofit 2.6.0 ! 更快捷的協程體驗 ！
- 2. async 更優雅異步體驗
- 3. Kotlin + 協程 + Retrofit + MVVM優雅的實現網絡請求
- 4. 【思貨】kotlin協程優雅的與Retrofit纏綿-正文
- 5. 【思貨】kotlin協程優雅的與Retrofit纏綿-kotlin DSL簡述
- 6. Retrofit+Rxjava網絡層的優雅封裝
- 7. retrofit-helper 簡潔的封裝retrofit，優雅的取消請求
- 8. RxHttp 優雅的實現請求串行與並行
- 9. Android OkHttp 史上最優雅的設置baseUrl
- 10. 優雅地使用Retrofit+RxJava(二)
- 更多相關文章...
- • MySQL的優勢（優點） - MySQL教程
- • Lua 協同程序(coroutine) - Lua 教程
- • 算法總結-深度優先算法
- • 算法總結-廣度優先算法
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. Retrofit 2.6.0 ! 更快捷的協程體驗 ！
- 2. async 更優雅異步體驗
- 3. Kotlin + 協程 + Retrofit + MVVM優雅的實現網絡請求
- 4. 【思貨】kotlin協程優雅的與Retrofit纏綿-正文
- 5. 【思貨】kotlin協程優雅的與Retrofit纏綿-kotlin DSL簡述
- 6. Retrofit+Rxjava網絡層的優雅封裝
- 7. retrofit-helper 簡潔的封裝retrofit，優雅的取消請求
- 8. RxHttp 優雅的實現請求串行與並行
- 9. Android OkHttp 史上最優雅的設置baseUrl
- 10. 優雅地使用Retrofit+RxJava(二)