基本使用
添加依赖
//retrofit 依赖
implementation 'com.squareup.retrofit2:retrofit:2.6.0'
implementation 'com.squareup.retrofit2:adapter-rxjava2:2.6.0'
implementation 'com.squareup.retrofit2:converter-gson:2.6.0'
//RxJava依赖
implementation 'io.reactivex.rxjava2:rxjava:2.2.8'
implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'
定义Api请求接口仓库
interface ApiStore {
@GET("/users/{user}/repos")
fun listRepos(@Path("user") user: String): Single
}
发起网络请求
val mRetrofit = Retrofit.Builder()
.baseUrl("https://api.github.com/")
.addConverterFactory(GsonConverterFactory.create())
.addCallAdapterFactory(RxJava2CallAdapterFactory.create())
//默认所有订阅都在IO线程中执行
//.addCallAdapterFactory(RxJava2CallAdapterFactory.createWithScheduler(Schedulers.io()))
.build()
val apiStore = mRetrofit.create(ApiStore::class.java)
apiStore.listRepos("hsicen")
.subscribeOn(Schedulers.newThread())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(object : SingleObserver {
override fun onSuccess(t: Any) {
Log.d("hsc", t.toString())
tv_info.text = t.toString()
}
override fun onSubscribe(d: Disposable) {
//获取可取消对象,方便后续取消请求
}
override fun onError(e: Throwable) {
Log.d("hsc", "请求失败")
tv_info.text = "请求失败"
}
})
框架结构
RxJava的整体结构是一条链
- 链的最上游:生产者(被观察者) Observable/Single/Flowable/Maybe
- 链的最下游:消费者(观察者) Observer/SingleObserver/Subscriber/MaybeObserver
- 链的中间:各个中介节点,即是下游的 Observable,又是上游的 Observer,连接(订阅) Subscribe
原理分析
先来看看简单的使用 Single.just(xxx)
Single.just(1)
.subscribe(object : SingleObserver {
override fun onSuccess(t: Int) {
tv_info.text = "$t"
}
override fun onSubscribe(d: Disposable) {
tv_info.text = "开始"
}
override fun onError(e: Throwable) {
tv_info.text = "出错"
}
})
这里我们利用Single.just(),在上游发送了一个简单的1,下游订阅这个事件,在onSuccess()中接收到事件后然后打印出来;由于Single没有后续事件,所以只有开始订阅onSubscribe,成功onSuccess,失败onError三个方法;可以看到上面的代码并没有进行线程的切换,所有事件的发生都是在当前线程中进行的,也就是UI线程
现在我们点进subscribe中,看看上游和下游是怎样连接起来的
public final void subscribe(SingleObserver observer) {
ObjectHelper.requireNonNull(observer, "observer is null");
observer = RxJavaPlugins.onSubscribe(this, observer);
ObjectHelper.requireNonNull(observer, "The RxJavaPlugins.onSubscribe hook returned a null SingleObserver. Please check the handler provided to RxJavaPlugins.setOnSingleSubscribe for invalid null returns. Further reading: https://github.com/ReactiveX/RxJava/wiki/Plugins");
try {
subscribeActual(observer);
} catch (NullPointerException ex) {
throw ex;
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
NullPointerException npe = new NullPointerException("subscribeActual failed");
npe.initCause(ex);
throw npe;
}
}
可以看到在这个方法中起主要作用的就一句代码 subscribeActual(observer)
, 所以我们只需要找到这个方法,看它里面做了什么操作,就知道是怎样连接起来的了,下面我们就点进这个方法
protected abstract void subscribeActual(@NonNull SingleObserver observer);
这是一个抽象方法,没有具体的实现,但是我们可以发现,这是Single这个类的抽象方法,所以们只需要找到这个类的实现类,也就可以找到这个抽象方法的具体实现;但是先别忙,我们不是还有一句代码没有看么,那我们先看看Single.just()做了什么操作
public static Single just(final T item) {
ObjectHelper.requireNonNull(item, "item is null");
return RxJavaPlugins.onAssembly(new SingleJust(item));
}
这个方法没有做什么操作,最主要的就是最后一句代码,返回了一个SingleJust对象,这个SingleJust应该就是Just的实现类,现在我们点进这个类
public final class SingleJust extends Single {
final T value;
public SingleJust(T value) {
this.value = value;
}
@Override
protected void subscribeActual(SingleObserver observer) {
observer.onSubscribe(Disposables.disposed());
observer.onSuccess(value);
}
}
可以看到在这个类的subscribeActual方法中,直接调用了下游的onSubscribe()和onSuccess()方法,onError方法都不需要调用,而且在订阅的时候调用的是Disposables.disposed()
,应该是要返回一个可取消订阅的对象,那么点进这个方法,看看返回的是什么对象
public static Disposable disposed() {
return EmptyDisposable.INSTANCE;
}
public enum EmptyDisposable implements QueueDisposable