参考文章

public class FilterOperator {

    public static void filter() {
        Observable.range(1, 10)//初始化## ObservableRange
                .filter(new Predicate<Integer>() {//初始化 ObservableFilter
                    @Override#3
                    public boolean test(Integer integer) throws Throwable {
                        return integer > 5;
                    }
                })
                .subscribe(observer);//ObservableFilter发起对观察者调用
    }

    static Observer observer = new Observer<Object>() {
        //观察者的订阅事件优先于被观察者发送事件
        @Override #1
        public void onSubscribe(@NonNull Disposable d) {
        }

        @Override#2
        public void onNext(@NonNull Object o) {
        }

        @Override
        public void onError(@NonNull Throwable e) {
        }

        @Override
        public void onComplete() {
        }
    };

}

1. range、filter都是调用抽象类Observable方法。具体操作符实例在Observable完成初始化，并且将上一级操作符作为当前操作符实例的source属性。
2. 观察者Observer#onSubscribe只会被调用一次，而且是链式中第一个Observable完成调用。
3. 所有操作符实例都是Observable的子类。
4. 所有操作符实例调用subscribe方法都是调用父类Observable#subscribe，并且通过抽象方法subscribeActual完成具体操作。
5. 最初的观察者Observer由最后中间操作符实例持有。

链式调用过程是对Observable类型的中间操作符实例初始化过程。 subscribe过程是反向调用过程。由最后一个操作符实例反向逐渐调用第一个操作符实例的过程。

1、Observable

public static Observable<Integer> range(int start, int count) {
    return RxJavaPlugins.onAssembly(new ObservableRange(start, count));
}

public final Observable<T> filter(@NonNull Predicate<? super T> predicate) {
    //this 指代其上级Observable之ObservableRange
    return RxJavaPlugins.onAssembly(new ObservableFilter<>(this, predicate));
}

public final void subscribe(@NonNull Observer<? super T> observer) {
    observer = RxJavaPlugins.onSubscribe(this, observer);
    Objects.requireNonNull(observer, "observer is null");
    subscribeActual(observer);
}

1. 首次由ObservableFilter发起subscribeActual调用，完成ObservableFilter的初始化。
2. 其次由ObservableRange发起subscribeActual调用。

1.1、ObservableRange

protected void subscribeActual(Observer<? super Integer> o) {//FilterObserver观察者
    RangeDisposable parent = new RangeDisposable(o, start, end);
    o.onSubscribe(parent);
    parent.run();
}

1. onSubscribe通过调用FilterObserver的抽象父类BasicFuseableObserver#onSubscribe【只调用一次】。

RangeDisposable(Observer<? super Integer> actual, long start, long end) {
    this.downstream = actual;//FilterObserver观察者
    this.index = start;
    this.end = end;
}

static final class RangeDisposable extends BasicIntQueueDisposable<Integer> {

    RangeDisposable(Observer<? super Integer> actual, long start, long end) {
        this.downstream = actual;
        this.index = start;
        this.end = end;
    }

    void run() {
        if (fused) {
            return;
        }
        Observer<? super Integer> actual = this.downstream;
        long e = end;
        for (long i = index; i != e && get() == 0; i++) {
            actual.onNext((int)i);//FilterObserver#onNext
        }
        if (get() == 0) {
            lazySet(1);
            actual.onComplete();
        }
    }
}

1. downstream为FilterObserver。

1.2、ObservableFilter

class ObservableFilter extends AbstractObservableWithUpstream {
    final Predicate<? super T> predicate;
    
    public ObservableFilter(ObservableSource source, Predicate predicate) {
        super(source);//ObservableRange
        this.predicate = predicate;
    }
    
    //observer 为FilterOperator类中初始化的观察者
    @Override
    public void subscribeActual(Observer<? super T> observer) {
        //source:ObservableRange
        // 因为需要调用Observable#subscribe，入参必须为Observer
        source.subscribe(new FilterObserver<>(observer, predicate));
    }

    static final class FilterObserver<T> extends BasicFuseableObserver<T, T> {
        final Predicate<? super T> filter;

        FilterObserver(Observer<? super T> actual, Predicate<? super T> filter) {
            super(actual);//FilterOperator类中初始化的观察者,BasicFuseableObserver构造方法
            this.filter = filter;
        }

        @Override
        public void onNext(T t) {
            if (sourceMode == NONE) {
                boolean b;
                try {
                    b = filter.test(t);//#3
                } catch (Throwable e) {
                    fail(e);
                    return;
                }
                if (b) {//如果返回true，则调用#2
                    downstream.onNext(t);
                }
            } else {
                downstream.onNext(null);
            }
        }

        @Override
        public int requestFusion(int mode) {
            return transitiveBoundaryFusion(mode);
        }

        @Nullable
        @Override
        public T poll() throws Throwable {
            for (;;) {
                T v = qd.poll();
                if (v == null || filter.test(v)) {
                    return v;
                }
            }
        }
    }
}

1. 由ObservableRange发起对观察者FilterObserver的订阅。[其实调用父类Observable#subscribe]

1.2.1、FilterObserver观察者

1.2.2、BasicFuseableObserver

abstract class BasicFuseableObserver<T, R> implements Observer<T>, QueueDisposable<R> {

 
    public BasicFuseableObserver(Observer<? super R> downstream) {
        this.downstream = downstream;//FilterOperator类中初始化的观察
    }

    
    public final void onSubscribe(Disposable d) {
        if (DisposableHelper.validate(this.upstream, d)) {

            this.upstream = d;
            if (d instanceof QueueDisposable) {
                this.qd = (QueueDisposable<T>)d;
            }

            if (beforeDownstream()) {
                //downstream为最初的观察者 #1
                downstream.onSubscribe(this);
                afterDownstream();
            }

        }
    }
}

1.2.3、AbstractObservableWithUpstream

abstract class AbstractObservableWithUpstream<T, U> extends Observable<U> implements HasUpstreamObservableSource<T> {

    /** The source consumable Observable. */
    protected final ObservableSource<T> source;

    /**
     * Constructs the ObservableSource with the given consumable.
     * @param source the consumable Observable
     */
    AbstractObservableWithUpstream(ObservableSource<T> source) {
        this.source = source;
    }

    @Override
    public final ObservableSource<T> source() {
        return source;
    }

}