Rxjava操作符源码分析

just():

    //这里的变换 a 的值时为了说明下面的 defer() 操作符
    a = 10;
    Observable<Integer> justObservable = Observable.just(a);
    a = 12;
    justObservable.subscribe(new Consumer<Integer>() {
        @Override
        public void accept(@NonNull Integer integer) throws Exception {
            Log.i("TAG", "accept: " + integer);
        }
    });

输出:
accept: 10

分析:

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

第一行是判空 , 第二行的RxjavaPlugins是为了实现hook , 下面都会忽略这两个 .
返回的是 new ObservableJust<T>(item)

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();
    }
}

这里跳过了很多细节 , 为的只是将操作符的实现 . 具体可以自己去看源码 .
ObservableJust将我们传过来的 a 存在 ObservableJust对象当中 . 所以 just() 操作符返回的是一个 持有我们传过去的 a 的ObservableJust对象 . 当订阅之后会执行相应的方法 .

defer():

a = 10;
Observable<Integer> deferObservable = Observable.defer(new Callable<ObservableSource<? extends Integer>>() {
    @Override
    public ObservableSource<? extends Integer> call() throws Exception {
        return Observable.just(a);
    }
});
a = 12;
deferObservable.subscribe(new Consumer<Integer>() {
    @Override
    public void accept(@NonNull Integer integer) throws Exception {
        Log.i("TAG", "accept: " + integer);
    }
});

输出:
accept: 12

分析:
defer() 中传过去的是一个callable对象 .

    public static <T> Observable<T> defer(Callable<? extends ObservableSource<? extends T>> supplier) {
        ObjectHelper.requireNonNull(supplier, "supplier is null");
        return RxJavaPlugins.onAssembly(new ObservableDefer<T>(supplier));
    }

public final class ObservableDefer<T> extends Observable<T> {
   
    final Callable<? extends ObservableSource<? extends T>> supplier;
    public ObservableDefer(Callable<? extends ObservableSource<? extends T>> supplier) {
        this.supplier = supplier;
    }
}

返回了ObservableDefer对象 , 存入了callable .

    @Override
    public void subscribeActual(Observer<? super T> s) {
        ObservableSource<? extends T> pub;
        try {
            pub = ObjectHelper.requireNonNull(supplier.call(), "null publisher supplied");
        } catch (Throwable t) {
            Exceptions.throwIfFatal(t);
            EmptyDisposable.error(t, s);
            return;
        }

        pub.subscribe(s);
    }

当订阅方法执行的时候 , 会调用 callable的call() 方法 获取我们在call()方法中返回的 ObservableSource , 接着调用 ObservableSource 的 subscribe()方法 , 相继调用onNext()等方法 , defer()方法是懒加载创建被观察者 , 所以在 a 变换之后 , 返回的也是变换过后的 a .

fromArray():

    @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.NONE)
    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()方法 , 如果是空的 , 返回一个空的被观察者 , 如果只有一个 , 那么调用 Observable.just()方法 , 如果长度 > 1 返回一个ObservableFromArray对象 .

public final class ObservableFromArray<T> extends Observable<T> {
   
    final T[] array;
    public ObservableFromArray(T[] array) {
        this.array = array;
    }
}

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();
    }

订阅之后 , 会调用FromArrayDisposable的 run()方法

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();
            }
        }

这里利用 for 循环 , 获取值 , 并且调用onNext()方法 , 如果值为null , 停止循环并且调用onError()方法 .
fromIterable() 也一样 , 是利用 Iterator 来遍历 .

interval():

    @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.CUSTOM)
    public static Observable<Long> interval(long initialDelay, long period, TimeUnit unit, Scheduler scheduler) {
        ObjectHelper.requireNonNull(unit, "unit is null");
        ObjectHelper.requireNonNull(scheduler, "scheduler is null");

        return RxJavaPlugins.onAssembly(new ObservableInterval(Math.max(0L, initialDelay), Math.max(0L, period), unit, scheduler));
    }

interval()有很多重载 , 最终调用上面这个方法 . 返回的是ObservableInterval对象 , 默认传过去的Schedulars.computation线程 ,

    @Override
    public void subscribeActual(Observer<? super Long> s) {
        IntervalObserver is = new IntervalObserver(s);
        s.onSubscribe(is);

        Disposable d = scheduler.schedulePeriodicallyDirect(is, initialDelay, period, unit);

        is.setResource(d);
    }

订阅之后会调用 , scheduler的计时器方法 .

        @Override
        public void run() {
            if (get() != DisposableHelper.DISPOSED) {
                actual.onNext(count++);
            }
        }

会按照时间 , 去调用这个方法 .

range():

    Observable.range(1 , 4)
            .subscribe(new Consumer<Integer>() {
        @Override
        public void accept(@NonNull Integer integer) throws Exception {
            Log.i("TAG", "accept: " + integer);
        }
    });

输出:
accept: 1
accept: 2
accept: 3
accept: 4

分析:

    @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.NONE)
    public static Observable<Integer> range(final int start, final int count) {
        if (count < 0) {
            throw new IllegalArgumentException("count >= 0 required but it was " + count);
        }
        if (count == 0) {
            return empty();
        }