RxJava2源码分析二之just、fromArray、fromIterable

Observable.just：接收1个以上,10个以下的参数，然后逐个发射。

Observable.fromArray：接收一个数组，从数组中一个一个取出来发射。

今天从源码来看一下Observable的just方法和FromArray。

public static <T> Observable<T> just(T item) {
        ObjectHelper.requireNonNull(item, "The item is null");
        return RxJavaPlugins.onAssembly(new ObservableJust<T>(item));
}

public static <T> Observable<T> just(T item1) {
     //...
}

//...

public static <T> Observable<T> just(T item1, T item2, T item3, T item4) {
        ObjectHelper.requireNonNull(item1, "The first item is null");
        ObjectHelper.requireNonNull(item2, "The second item is null");
        ObjectHelper.requireNonNull(item3, "The third item is null");
        ObjectHelper.requireNonNull(item4, "The fourth item is null");

        return fromArray(item1, item2, item3, item4);
}

//...

public static <T> Observable<T> just(T item1, T item2, T item3, T item4, T item5, T item6, T item7, T item8, T item9, T item10) {
    //...
}

通过源码可以看到，just方法又多个重载方法，参数从1到10。由此可以知道，just接收1个以上10个以下参数。以4个参数的just方法为例。just会对所有参数逐个判空。然后调用fromArray方法，这里很明显，除了只接收1个参数的just之外，just方法最终调用的是。

先看接收1个参数的just方法，这里返回RxJavaPlugins.onAssembly(new ObservableJust<T>(item))。RxJavaPlugins.onAssembly上一篇文章讲过它的作用，这里直接返回的是ObservableJust的对象。ObservableJust它继承自Observable类，在上一篇文章中可以知道，在Observable与Observer发生订阅关系的使用调用的subscribe方法会用到Observable的subscribeActual方法。所以这里会调用ObservableJust的subscribeActual方法。

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

public static final class ScalarDisposable<T>
    extends AtomicInteger
    implements QueueDisposable<T>, Runnable {

        final Observer<? super T> observer;

        final T value;

        static final int START = 0;
        static final int FUSED = 1;
        static final int ON_NEXT = 2;
        static final int ON_COMPLETE = 3;

        public ScalarDisposable(Observer<? super T> observer, T value) {
            this.observer = observer;
            this.value = value;
        }

       //...

        @Override
        public void run() {
            if (get() == START && compareAndSet(START, ON_NEXT)) {
                observer.onNext(value);
                if (get() == ON_NEXT) {
                    lazySet(ON_COMPLETE);
                    observer.onComplete();
                }
            }
        }
    }

在ObservableJust的subscribeActual方法中，先创建ScalarDisposable，紧接着调用run方法。ScalarDisposable继承AtomicInteger类，在run方法中调用get()方法返回的是内存中保存着一个值o，一开始是和START一样为0。

public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}

compareAndSet方法是AtomicInteger中的方法，它的作用是：判断expect和0是不是想等，如果相等则将0的值改成update。

接着就是调用observer.onNext(value);因为参数之后一个，并且0的值改成了ON_NEXT，所以很快调用了observer.onComplete();。lazySet(ON_COMPLETE);的作用是延迟一会儿设置o的值为ON_COMPLETE。

到这，只接收一个参数的just方法分析完成，接收多个参数的just会将参数转换成数组，调用fromArray方法。下面看fromArray方法。

public static <T> Observable<T> fromArray(T... items) {
        ObjectHelper.requireNonNull(items, "items is null");
        if (items.length == 0) {
            return empty();
        } else
        if (items.length == 1) {
            return just(items[0]);
        }
        return RxJavaPlugins.onAssembly(new ObservableFromArray<T>(items));
}

可以看到fromArray方法中，分为数组长度为0，1，大于1的情况。其中长度为1时，调用接收一个参数的just方法。为0时调用empty()方法。

public static <T> Observable<T> empty() {
        return RxJavaPlugins.onAssembly((Observable<T>) ObservableEmpty.INSTANCE);
}

public final class ObservableEmpty extends Observable<Object> implements ScalarCallable<Object> {
    public static final Observable<Object> INSTANCE = new ObservableEmpty();

    private ObservableEmpty() {
    }

    @Override
    protected void subscribeActual(Observer<? super Object> o) {
        EmptyDisposable.complete(o);
    }

   //...
}


public static void complete(Observer<?> s) {
        s.onSubscribe(INSTANCE);
        s.onComplete();
}

在empty()方法中，返回的是ObservableEmpty对象。在ObservableEmpty类中可以看到subscribeActual方法调用EmptyDisposable.complete，在这个方法中，可以看到，只调用了Observer的onSubscribe和onComplete方法。

当fromArray中数组长度大于1时，返回ObservableFromArray的类对象。

public void subscribeActual(Observer<? super T> s) {
        FromArrayDisposable<T> d = new FromArrayDisposable<T>(s, array);

        s.onSubscribe(d);

        if (d.fusionMode) {
            return;
        }

        d.run();
    }

 static final class FromArrayDisposable<T> extends BasicQueueDisposable<T> {

        final Observer<? super T> actual;

        final T[] array;


        FromArrayDisposable(Observer<? super T> actual, T[] array) {
            this.actual = actual;
            this.array = array;
        }

    //...

        void run() {
            T[] a = array;
            int n = a.length;

            for (int i = 0; i < n && !isDisposed(); i++) {
                T value = a[i];
                if (value == null) {
                    actual.onError(new NullPointerException("The " + i + "th element is null"));
                    return;
                }
                actual.onNext(value);
            }
            if (!isDisposed()) {
                actual.onComplete();
            }
        }
    }
}

可以看到subscribeActual方法创建FromArrayDisposable对象，最终调用FromArrayDisposable对象的run方法。在这个方法中通过for循环调用Observer的onNext方法处理接收的数据。

fromArray结束之后，再看一下fromIterable。

public static <T> Observable<T> fromIterable(Iterable<? extends T> source) {
        ObjectHelper.requireNonNull(source, "source is null");
        return RxJavaPlugins.onAssembly(new ObservableFromIterable<T>(source));
}

public final class ObservableFromIterable<T> extends Observable<T> {
    final Iterable<? extends T> source;
    public ObservableFromIterable(Iterable<? extends T> source) {
        this.source = source;
    }

    @Override
    public void subscribeActual(Observer<? super T> s) {
        Iterator<? extends T> it;
        try {
            it = source.iterator();
        } catch (Throwable e) {
            Exceptions.throwIfFatal(e);
            EmptyDisposable.error(e, s);
            return;
        }
        boolean hasNext;
        try {
            hasNext = it.hasNext();
        } catch (Throwable e) {
            Exceptions.throwIfFatal(e);
            EmptyDisposable.error(e, s);
            return;
        }
        if (!hasNext) {
            EmptyDisposable.complete(s);
            return;
        }

        FromIterableDisposable<T> d = new FromIterableDisposable<T>(s, it);
        s.onSubscribe(d);

        if (!d.fusionMode) {
            d.run();
        }
    }

    static final class FromIterableDisposable<T> extends BasicQueueDisposable<T> {

        FromIterableDisposable(Observer<? super T> actual, Iterator<? extends T> it) {
            this.actual = actual;
            this.it = it;
        }

         void run() {
            boolean hasNext;

            do {
                if (isDisposed()) {
                    return;
                }
                T v;

                try {
                    v = ObjectHelper.requireNonNull(it.next(), "The iterator returned a null value");
                } catch (Throwable e) {
                    Exceptions.throwIfFatal(e);
                    actual.onError(e);
                    return;
                }

                actual.onNext(v);

                if (isDisposed()) {
                    return;
                }
                try {
                    hasNext = it.hasNext();
                } catch (Throwable e) {
                    Exceptions.throwIfFatal(e);
                    actual.onError(e);
                    return;
                }
            } while (hasNext);

            if (!isDisposed()) {
                actual.onComplete();
            }
        }
     
    }

这里创建了ObservableFromIterable对象，可以看到，代码很简单，也是通过迭代器的方式处理接收到的数据。

RxJava2源码分析二之just、fromArray、fromIterable

猜你喜欢