阅读 253

啃源码 - RxJava(事件流的创建与接收)

rxjava的基本用法

Observable.create(new ObservableOnSubscribe<Integer>() {//创建事件源
    @Override
    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
        emitter.onNext(1);
        emitter.onNext(2);
        emitter.onNext(3);
        emitter.onComplete();
    }
}).subscribe(new Observer<Integer>() {//创建观测者,并对事件源进行观测
    @Override
    public void onSubscribe(Disposable d) {
    }

    @Override
    public void onNext(Integer integer) {
        System.out.println(integer.toString());
    }

    @Override
    public void onError(Throwable e) {
    }

    @Override
    public void onComplete() {
        System.out.println("onComplete------");
    }
});
复制代码

这是对rxjava最基本的用法,创建一个事件源,创建一个观察者,再对事件源进行订阅,执行结果: 1 2 3 onComplete------

我们再看Observable.create方法

public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
    ObjectHelper.requireNonNull(source, "source is null");
    return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
}
复制代码

返回一个observable,看一下observable的继承关系,observable实现了ObservableSource,ObservableSource里面只有一个订阅的方法,需要一个observer的参数,observer也是一个接口,里面有四个方法,onSubscribe,onNext,onError,onComplete。这四个方法就是观察者在订阅的时候触发的四个方法,从两个接口来看,也就是一个事件源,一个观察者,就可以构成一个完整的事件流了,那我们自己尝试写一个

public class ObservableDemo implements ObservableSource<Integer> {
    @Override
    public void subscribe(Observer<? super Integer> observer) {
        try {
            observer.onNext(1);
            observer.onNext(2);
            observer.onNext(3);
            observer.onComplete();
        } catch (Exception e) {
            e.printStackTrace();
            observer.onError(e);
        }
    }
}

new ObservableDemo().subscribe(new Observer<Integer>() {
        @Override
        public void onSubscribe(Disposable d) {
        }

        @Override
        public void onNext(Integer integer) {
            System.out.println(integer.toString());
        }

        @Override
        public void onError(Throwable e) {
        }

        @Override
        public void onComplete() {
            System.out.println("onComplete------");
        }
    });
复制代码

执行结果: 1 2 3 onComplete------

跟上面用create构建是一样的结果,那为什么作者要提供一个create的api呢?我们来看看跟着create来看看 create其实是 new 了一个ObservableCreate来创建事件源,那我们继续点进去看ObservableCreate,他实现了一个subscribeActual方法,observablesource里面是subscribe,那我们看看observable里面的subscribe实现

public final void subscribe(Observer<? super T> observer) {
    ObjectHelper.requireNonNull(observer, "observer is null");
    try {
        observer = RxJavaPlugins.onSubscribe(this, observer);

        ObjectHelper.requireNonNull(observer, "Plugin returned null Observer");

        subscribeActual(observer);
    } catch (NullPointerException e) { // NOPMD
        throw e;
    } catch (Throwable e) {
        Exceptions.throwIfFatal(e);
        // can't call onError because no way to know if a Disposable has been set or not
        // can't call onSubscribe because the call might have set a Subscription already
        RxJavaPlugins.onError(e);

        NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to     RS");
        npe.initCause(e);
        throw npe;
    }
}
复制代码

subscribe里面调用了subscribeActual(observer)方法,subscribeActual是抽象方法,那我们继续看ObservableCreate里面的subscribeActual

protected void subscribeActual(Observer<? super T> observer) {
    CreateEmitter<T> parent = new CreateEmitter<T>(observer);
    observer.onSubscribe(parent);

    try {
        source.subscribe(parent);
    } catch (Throwable ex) {
        Exceptions.throwIfFatal(ex);
        parent.onError(ex);
    }
}
复制代码

CreateEmitter实现了Disposable,Emitter.Emitter有三个方法可以发送三种事件onNext,onError,onComplete observer.onSubscribe(parent)调用了observer的onSubscribe方法,并将CreateEmitter作为参数,而CreateEmitter又是Disposable, 下面继续调用了source.subscribe(parent),source是ObservableOnSubscribe,里面也有一个void subscribe(ObservableEmitter emitter)方法,我们在创建的时候就可以使用emitter来发送事件,这个事件又是怎么让观察者接收到的呢?

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方法,所以事件就这样被observer接收到,onError与onComplete同理。

来回顾一下,我们分析了事件源的创建,以及事件源的接收的过程,事件流总是直接或间接调用的observer的方法来达到事件传递的目的,趁热打铁,我们再来看一下just,跟create有点相似,创建了一个ObservableJust,继续点进去

public final class ObservableJust<T> extends Observable<T> implements ScalarCallable<T> {

    private final T value;
    public ObservableJust(final T value) {
        this.value = value;
    }

    @Override
    protected void subscribeActual(Observer<? super T> s) {
        ScalarDisposable<T> sd = new ScalarDisposable<T>(s, value);
        s.onSubscribe(sd);
        sd.run();
    }

    @Override
    public T call() {
        return value;
    }
}
复制代码

代码非常少,还是看subscribeActual,创建了一个ScalarDisposable,马上就调用了onSubscribe,又继续调用了run,跟进去

public void run() {
    if (get() == START && compareAndSet(START, ON_NEXT)) {
        observer.onNext(value);
        if (get() == ON_NEXT) {
            lazySet(ON_COMPLETE);
            observer.onComplete();
        }
    }
}
复制代码

好吧,可以清除的看到在run里面调用了onNext以及onComplete,类似的我们看一下其他的继承自observable的类,可以看到很多我们经常用到的创建方式,ObservableNever,ObservableEmpty,ObservableInterval,ObservableRange,ObservableTimer,ObservableZip等等,这些都是用来创建事件源的,像这些类都是由final进行修饰的,这么多final修饰的类中我看到了一个抽象的类AbstractObservableWithUpstream,从字面意思Upstream来猜测,这个类应该是对上游时间进行包裹的的类,哦,那不是类似于map以及flatmap这些都操作符难道是对上游事件源进行包裹的吗(猜测而已嘛,随便猜),恩带着这个疑问我们下一篇在进行验证

文章分类
Android
文章标签