啃源码 - RxJava（事件流的创建与接收）-CSDN博客

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这些都操作符难道是对上游事件源进行包裹的吗(猜测而已嘛，随便猜)，恩带着这个疑问我们下一篇在进行验证