RxJava2原理解析

基本使用

添加依赖

//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的整体结构是一条链

1. 链的最上游：生产者(被观察者) Observable/Single/Flowable/Maybe
2. 链的最下游：消费者(观察者) Observer/SingleObserver/Subscriber/MaybeObserver
3. 链的中间：各个中介节点，即是下游的 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