继续上一篇之后 MonkeyLei：Retrofit2+Rxjava-Rxjava2.x-篇一-用起来 ，上篇简单的对网络请求做了实践，过程对上下游线程，对线程切换，以及map/flatmap的简单做了了解。然后对RxJava1.x和RxJava2.x的区别那些也做了了解，相关的链接，官方的/网友的都是小萌新忒么搬来的，O(∩_∩)O哈哈~
小萌新上一篇还想这样：就是知识看的太少了，不知道咋整。。。
image
实际上，群友都告诉我说，你要么再封装一层Observable，当然也可以用操作符map/flatmap这些来做链式处理！所以可能可能要纠正下之前的说法！
map看看呢!
.observeOn(Schedulers.io()) // 还可以指定一个io线程, 用map的形式进行预处理
.map(object: Function<List<Repo>, List<Repo>>{
override fun apply(t: List<Repo>): List<Repo> {
Log.e("observable map", "flatMap thread'name=" + Thread.currentThread().name)
return t
}
})
flatMap看看呢？ - 链表List<Repo>我们可以做一些特殊，甚至是耗时处理！
.observeOn(Schedulers.io()) // 上一次请求的结果回调中，我们还是拿来在io线程中做预处理
.flatMap(object: Function<List<Repo>, ObservableSource<List<Repo>>>{
override fun apply(t: List<Repo>): ObservableSource<List<Repo>> {
// 这里是io线程，可以做一些耗时操作，然后返给onNext的UI线程
Log.e("observable", "flatMap thread'name=" + Thread.currentThread().name)
// 原样的给返回去
return Observable.fromArray(t);
}
})
你要注意，这种线程指定与处理的成对出现！map/flatMap处理后，之后你可以切换到UI线程：
.observeOn(AndroidSchedulers.mainThread()) // 请求都完成后，切换到UI线程，将结果进行渲染
然后就可以进行subscribe的一个订阅，此时请求启动！这种逻辑小萌新要注解熟悉，当然可能重要的是看人家如何设计的，思想应该更重要一些！
Rxjava Retrofit okhttp 依次执行多个请求
https://blog.csdn.net/oneblue123/article/details/79784620
从上面来看，我们此时应该就可以利用flatMap再次做请求了，（返回值是Observable）。 map是不行的啦，map不能返回ObservableSource!
直接上代码如何：
GitHubService.kt
@GET("users/{user}/repos")
fun listReposStringRxJavaObservable(@Path("user") user: String): Observable<List<Repo>>
Main3Activity.kt
package com.hl.rxnettest
import android.support.v7.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import io.reactivex.Observable
import io.reactivex.ObservableSource
import io.reactivex.Observer
import io.reactivex.android.schedulers.AndroidSchedulers
import io.reactivex.disposables.Disposable
import io.reactivex.functions.Function
import io.reactivex.schedulers.Schedulers
import retrofit2.Retrofit
import retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory
import retrofit2.converter.gson.GsonConverterFactory
class Main3Activity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main3)
// 老样子，再来过一遍Retrofit请求流程
// 1\. 创建Retrofit实例
var retrofit = Retrofit.Builder()
.baseUrl("https://api.github.com/")
.addCallAdapterFactory(RxJava2CallAdapterFactory.create())
.addConverterFactory(GsonConverterFactory.create())
.build()
// 2\. 创建一个请求服务实例
var gitHubService = retrofit.create(GitHubService::class.java)
// 3\. 获取服务对应的请求实例
var gitCall = gitHubService.listReposStringRxJavaObservable("FanChael")
// 4.1 进行基本请求 - 指定上下游所在线程
var dis = gitCall.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe { t ->
//lamba表達式走起
for (item in t!!) {
// SuperStartElectronic subtitle display - 电子字幕展示-接机、演唱会、见面、展示专用.https://github.com/FanChael/SuperStart
// Log.e("observable", item.name + item.description + item.html_url)
}
}
// 4.2 有时候，我们需要连续做两次请求，比如提交订单成功后，然后调起支付接口(至于后续支付结果干什么，暂时不管！)
// 如果我们不采用map，flatmap等操作符来做连续请求的话，按照小萌新之前的写法就是在第一次onNext成功回调里面，再次发起一次subscribe请求，同样的请求代码还会再写一次！
// 而RxJava已经考虑到了这一点，为我们准备了更方便的操作符。这里就拿flatmap为例？
// --flatmp需要返回的是一个ObservableSource，这时候就返回上游的observable对象
// let'start
gitCall.subscribeOn(Schedulers.io())
.observeOn(Schedulers.io()) // 由于请求结果还需要拿来再做一次网络请求，因此我们再次放到io下线程中处理
.flatMap(object: Function<List<Repo>, ObservableSource<List<Repo>>>{
override fun apply(t: List<Repo>): ObservableSource<List<Repo>> {
// 在进行一次请求 - 小萌新就将就重复调用了
// TODO t可以拿来作为再次请求时的的参数
Log.e("observable apply1", t.get(0).name)
Log.e("observable", "flatMap thread'name=" + Thread.currentThread().name)
return gitHubService.listReposStringRxJavaObservable("FanChael")
}
})
.observeOn(Schedulers.io()) // 上一次请求的结果回调中，我们还是拿来在io线程中做第三次请求
.flatMap(object: Function<List<Repo>, ObservableSource<List<Repo>>>{
override fun apply(t: List<Repo>): ObservableSource<List<Repo>> {
// 在进行一次请求 - 小萌新就将就重复调用了
// TODO t可以拿来作为再次请求时的的参数
Log.e("observable apply2", "ttt")
Log.e("observable", "flatMap thread'name=" + Thread.currentThread().name)
return gitHubService.listReposStringRxJavaObservable("FanChael")
}
})
.observeOn(Schedulers.io()) // 上一次请求的结果回调中，我们还是拿来在io线程中做预处理
.flatMap(object: Function<List<Repo>, ObservableSource<List<Repo>>>{
override fun apply(t: List<Repo>): ObservableSource<List<Repo>> {
// 这里是io线程，可以做一些耗时操作，然后返给onNext的UI线程
Log.e("observable", "flatMap thread'name=" + Thread.currentThread().name)
// 原样的给返回去
return Observable.fromArray(t);
}
})
.observeOn(AndroidSchedulers.mainThread()) // 请求都完成后，切换到UI线程，将结果进行渲染
.subscribe(object : Observer<List<Repo>>{
override fun onComplete() {
}
override fun onSubscribe(d: Disposable) {
}
override fun onNext(t: List<Repo>) {
Log.e("observable onNext", t[0].name)
}
override fun onError(e: Throwable) {
}
})
}
}
老样子，依赖别忘:
implementation 'com.squareup.retrofit2:retrofit:2.6.0'
implementation 'com.squareup.retrofit2:converter-gson:2.6.0'
implementation 'com.squareup.retrofit2:adapter-rxjava:2.6.0'
// 最新支持rxjava2的适配器 https://github.com/square/retrofit/tree/master/retrofit-adapters/rxjava2
implementation 'com.squareup.retrofit2:adapter-rxjava2:2.6.0'
// https://github.com/ReactiveX/RxAndroid
// https://github.com/ReactiveX/RxJava
implementation "io.reactivex.rxjava2:rxjava:2.2.9"
implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'
结果：
06-20 14:34:43.005 8154-8161/? E/zygote64: Failed sending reply to debugger: Broken pipe
06-20 14:34:44.911 8154-8186/com.hl.rxnettest E/observable apply1: banner
06-20 14:34:44.911 8154-8186/com.hl.rxnettest E/observable: flatMap thread'name=RxCachedThreadScheduler-3
06-20 14:34:45.469 8154-8187/com.hl.rxnettest E/observable map: flatMap thread'name=RxCachedThreadScheduler-4
06-20 14:34:45.470 8154-8188/com.hl.rxnettest E/observable apply2: ttt
06-20 14:34:45.470 8154-8188/com.hl.rxnettest E/observable: flatMap thread'name=RxCachedThreadScheduler-5
06-20 14:34:46.075 8154-8189/com.hl.rxnettest E/observable: flatMap thread'name=RxCachedThreadScheduler-6
06-20 14:34:46.076 8154-8154/com.hl.rxnettest E/observable onNext: banner
这里需要注意的是, flatMap并不保证事件的顺序 - 如果需要保证顺序则需要使用concatMap
不是搬砖，胜似搬砖! - 小萌新还是很努力的，就是努力的有点慢，努力的有点坑！
网友评论