1. 程式人生 > >RxHttp ,比Retrofit 更優雅的協程體驗

RxHttp ,比Retrofit 更優雅的協程體驗

1、前言

Hello,各位小夥伴,又見面了,回首過去,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.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.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.postForm("/service/...")     
    .toDownload(localPath)  //下載需要傳入本地檔案路徑   
    .await()

下載呼叫toDownload(String)方法,傳入本地檔案路徑即可,要監聽下載進度?也簡單,如下:

val localPath = "sdcard//android/data/..../1.apk"  
val student = RxHttp.postForm("/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.postForm("/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快取最優解

最後,開源不易,寫文章更不易,還需要勞煩大家給本文點個贊,可以的話,再給個star,感覺不盡,