RxJava2——1之数据发送和接收

RxJava2与RxJava相比不同之处

1、package的更改

rx1包名由原来的rx.xxx更改为io.reactivex.xxx，并且在同一个module之下，rx1和rx2是不兼容的。

2、背压支持

RxJava在1.0只有一个个观察者模式，只能部分支持背压

• Observable(被观察者)/Observer（观察者）
• Observable(被观察者)/Subscriber(观察者)

RxJava在2.0出现了两个观察者模式，新增的Flowable支持背压，而Observable是不支持背压的

• Observable(被观察者)/Observer（观察者）
• Flowable(被观察者)/Subscriber(观察者)

背压是指在异步场景中，被观察者发送事件速度远快于观察者的处理速度的情况下，一种告诉上游的被观察者降低发送速度的策略，简而言之，背压是流速控制的一种策略。

 

RxJava是函数响应式编程思想在java语言上的具体实现。

我用的版本：

implementation "io.reactivex.rxjava2:rxjava:2.2.8"
implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'

Observable(被观察者)，Observer(观察者)

1、先创建被观察者：创建被观察者源码分析如下。

ObservableOnSubscribe是一个接口，代码如下：

ObservableCreate继承于Observable,Observable是一个抽象类。

onAssembly方法内容

2、创建观察者

3、订阅：源码分析如下。

继续查看subscribeActual方法，其实就是ObservableCreate中的方法，如下

这里的source指的就是创建被订阅者时的ObservableOnSubscribe,如下图所示。

在说明一下parent，其实parent 就是CreateEmitter，CreateEmitter是ObservableCreate的内部类

CreateEmitter是真正的逻辑处理类

static final class CreateEmitter<T>
extends AtomicReference<Disposable>
implements ObservableEmitter<T>, Disposable {

    private static final long serialVersionUID = -3434801548987643227L;

    final Observer<? super T> observer;

    CreateEmitter(Observer<? super T> observer) {
        this.observer = observer;
    }

    @Override
    public void onNext(T t) {
        if (t == null) {
            onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
            return;
        }
        if (!isDisposed()) {
            observer.onNext(t);//这里就是创建Observer时的onNext方法。
        }
    }

    @Override
    public void onError(Throwable t) {
        if (!tryOnError(t)) {
            RxJavaPlugins.onError(t);
        }
    }

    @Override
    public boolean tryOnError(Throwable t) {
        if (t == null) {
            t = new NullPointerException("onError called with null. Null values are generally not allowed in 2.x operators and sources.");
        }
        if (!isDisposed()) {
            try {
                observer.onError(t);
            } finally {
                dispose();
            }
            return true;
        }
        return false;
    }

    @Override
    public void onComplete() {
        if (!isDisposed()) {
            try {
                observer.onComplete();
            } finally {
                dispose();
            }
        }
    }

    @Override
    public void setDisposable(Disposable d) {
        DisposableHelper.set(this, d);
    }

    @Override
    public void setCancellable(Cancellable c) {
        setDisposable(new CancellableDisposable(c));
    }

    @Override
    public ObservableEmitter<T> serialize() {
        return new SerializedEmitter<T>(this);
    }

    @Override
    public void dispose() {
        DisposableHelper.dispose(this);
    }

    @Override
    public boolean isDisposed() {
        return DisposableHelper.isDisposed(get());
    }

    @Override
    public String toString() {
        return String.format("%s{%s}", getClass().getSimpleName(), super.toString());
    }
}

过程总结：
1、创建 Observable 返回 ObservableCreate
2、创建Observer对象，接着ObservableCreate 进行 subscribe，然后执行 subscribeActual
3、在 subscribeActual 中实际上是 ObservableOnSubscribe 调用 subscribe 然后执行 emitter.onNext("1");//发送
4、emitter.onNext("1"); 最终会去调用new Observer 中的 onNext（）
5、最终我们写在onNext() 的代码就被执行了，并且可以获取传过来的数据//接收