Rxjava2 all操作符

all操作符表示数据流需要满足指定的条件，结果要么成功要么失败。

  Observable.just(11, 12, 13, 14, 15)
                .all(integer -> integer < 20)
                .subscribe(result -> System.out.println("result:" + result));

代码中检查是不是所有的数据都是小于20，那么结果肯定是true。接下来我们看看代码是如何做到的。

  public final Single<Boolean> all(Predicate<? super T> predicate) {
        ...
        return RxJavaPlugins.onAssembly(new ObservableAllSingle<T>(this, predicate));
    }

Predicate是一个接口，里面有一个test方法，每个数据都会经过test，一但检测不通过，就会结束。

public interface Predicate<T> {
    boolean test(@NonNull T t) throws Exception;
}

public final class ObservableAllSingle<T> extends Single<Boolean> implements FuseToObservable<Boolean> {
    final ObservableSource<T> source;

    final Predicate<? super T> predicate;
    public ObservableAllSingle(ObservableSource<T> source, Predicate<? super T> predicate) {
        this.source = source;
        this.predicate = predicate;
    }

    @Override
    protected void subscribeActual(SingleObserver<? super Boolean> t) {
        source.subscribe(new AllObserver<T>(t, predicate));
    }

   ...

}

all操作符返回的结果是Single,它只有成功或者失败2个结果。不熟悉Single的可以看这里， 实现FuseToObservable接口可以从Single转换到Observable,在这里不重要，不用管它。

大家先记住subscribeActual这个方法，想一想这个方法是什么时候调用的？ 然后我们看看subscribe方法。

  public final Disposable subscribe(Consumer<? super T> onSuccess) {
        return subscribe(onSuccess, Functions.ON_ERROR_MISSING);
    }

  public final Disposable subscribe(final Consumer<? super T> onSuccess, final Consumer<? super Throwable> onError) {
      ...

        ConsumerSingleObserver<T> observer = new ConsumerSingleObserver<T>(onSuccess, onError);
        subscribe(observer);
        return observer;
    }

注意看这里的 subscribe(observer);

  public final void subscribe(SingleObserver<? super T> observer) {
        ...
         subscribeActual(observer);
        ...
    }

看到了没有，一旦调用subscribe方法，执行链就会到subscribeActual,好了，我们搞清楚subscribeActual方法是时候时候执行的了。

这里我们转战到AllObserver代码了

    @Override
        public void onNext(T t) {
            if (done) {
                return;
            }
            boolean b;
            try {
                b = predicate.test(t);
            } catch (Throwable e) {
                Exceptions.throwIfFatal(e);
                upstream.dispose();
                onError(e);
                return;
            }
            if (!b) {
                done = true;
                upstream.dispose();
                downstream.onSuccess(false);
            }
        }

随着observer调用onNext方法，这里的b是测试的结果，只要有一个不满足predicate的条件，数据流就会提前结束。

基于源码2.2.4版本