RxJava源码（简单操作符）

RxJava源码（从 just 开始）

RxJava源码（简单操作符）

RxJava源码（线程）

RxJava源码（背压）

RxJava源码（RxBinding）

RxJava源码（衍生 RxLifecycle）

RxJava github 地址：https://github.com/ReactiveX/RxJava/tree/2.x

RxJava 相关概念和一些用法这里不再赘述，可以查看官方文档 官方文档 以及其他的一些博客，闲话少说，这里直接从 rx 的 github 中简单用法去深入源码解读。

上篇文章中用了个最简单的示例详细的阅读了 RxJava 相关源码流程。抓住几个常用操作符大致浏览下，以增进印象，不再详细的跟进阅读。直接上代码

val subscribe = Flowable.range(1, 5)
                .map {
                    it * it
                }
                .filter {
                    it % 3 == 0
                }
                .subscribe {
                    System.out.println(it)
                }

进入 range 方法，它肯定是创建了一个继承 Flowable 的对象。

    public static Flowable<Integer> range(int start, int count) {
        //判读参数
        return RxJavaPlugins.onAssembly(new FlowableRange(start, count));
    }

public final class FlowableRange extends Flowable<Integer> 

如你所愿，创建了 FlowableRange，并将参数初始化。

进入 map 方法，它肯定也是创建一个一个继承 Flowable 的对象。

    public final <R> Flowable<R> map(Function<? super T, ? extends R> mapper) {
        ObjectHelper.requireNonNull(mapper, "mapper is null");
        return RxJavaPlugins.onAssembly(new FlowableMap<T, R>(this, mapper));
    }

public final class FlowableMap<T, U> extends AbstractFlowableWithUpstream<T, U> 
abstract class AbstractFlowableWithUpstream<T, R> extends Flowable<R> implements HasUpstreamPublisher<T>

 如你所愿，创建了 FlowableMap，并将参数初始化。看到传入了 this，当前方法是上一个 Flowable 调用，即 FlowableMap 中 source 是 FlowableRange

    public FlowableMap(Flowable<T> source, Function<? super T, ? extends U> mapper) {
        super(source);
        this.mapper = mapper;
    }

以此类推，filter 方法创建 FlowableFilter，此对象中包含 FlowableMap

    public final Flowable<T> filter(Predicate<? super T> predicate) {
        ObjectHelper.requireNonNull(predicate, "predicate is null");
        return RxJavaPlugins.onAssembly(new FlowableFilter<T>(this, predicate));
    }

public final class FlowableFilter<T> extends AbstractFlowableWithUpstream<T, T> {
    final Predicate<? super T> predicate;
    public FlowableFilter(Flowable<T> source, Predicate<? super T> predicate) {
        super(source);
        this.predicate = predicate;
    }
}

subscribe 方法，订阅开始了

subscribe 开始和前一篇一致，我们创建的 Consumer 转换为 LambdaSubscriber

进入了 subscribeActual 抽象方法中，此时是 FlowableFilter 调用此方法，所以先进入它的实现中。

    @Override
    protected void subscribeActual(Subscriber<? super T> s) {
        if (s instanceof ConditionalSubscriber) {
            source.subscribe(new FilterConditionalSubscriber<T>(
                    (ConditionalSubscriber<? super T>)s, predicate));
        } else {
            source.subscribe(new FilterSubscriber<T>(s, predicate));
        }
    }

 此处将 LambdaSubscriber 转换为 FilterSubscriber ，进入 FlowableMap 的订阅中，同样会调用 subscribeActual ，下面是 FlowableMap 的 subscribeActual 

    @Override
    protected void subscribeActual(Subscriber<? super U> s) {
        if (s instanceof ConditionalSubscriber) {
            source.subscribe(new MapConditionalSubscriber<T, U>((ConditionalSubscriber<? super U>)s, mapper));
        } else {
            source.subscribe(new MapSubscriber<T, U>(s, mapper));
        }
    }

FilterSubscriber 实现了 ConditionalSubscriber ，所以 FilterSubscriber 转换为 MapConditionalSubscriber ，之后自然进入 FlowableRange 的 subscribeActual

    @Override
    public void subscribeActual(Subscriber<? super Integer> s) {
        if (s instanceof ConditionalSubscriber) {
            //注意
            s.onSubscribe(new RangeConditionalSubscription(
                    (ConditionalSubscriber<? super Integer>)s, start, end));
        } else {
            s.onSubscribe(new RangeSubscription(s, start, end));
        }
    }

同样 MapConditionalSubscriber 实现了 ConditionalSubscriber ，所以将 MapConditionalSubscriber 转换为 RangeConditionalSubscription 

但，此处调用 MapConditionalSubscriber 的 onSubscribe 方法，MapConditionalSubscriber 没有onSubscribe，转父类 BasicFuseableConditionalSubscriber 

注意这里将 s 赋给 upstream

    public final void onSubscribe(Subscription s) {
        if (SubscriptionHelper.validate(this.upstream, s)) {

            this.upstream = s;
            if (s instanceof QueueSubscription) {
                this.qs = (QueueSubscription<T>)s;
            }

            if (beforeDownstream()) {

                downstream.onSubscribe(this);

                afterDownstream();
            }

        }
    }

downstream 是初始化时传入的上一个 Subscriber ，这里便是 FilterSubscriber

同理 FilterSubscriber 也在父类的 onSubscribe，此处的 downstream 为 LambdaSubscriber

进入 LambdaSubscriber 就好办了，经 RequestMax.INSTANCE 入 request

但此处的 get() 中 value 为 FilterSubscriber（setOnce），FilterSubscriber 没有实现 request，去父类 BasicFuseableSubscriber

    @Override
    public void request(long n) {
        upstream.request(n);
    }

此处 upstream 是在调用 onSubscribe 时传入的，因此 FilterSubscriber 的 upstream 是 MapConditionalSubscriber，同理 MapConditionalSubscriber 的 upstream 是 RangeConditionalSubscription

        @Override
        public final void request(long n) {
            if (SubscriptionHelper.validate(n)) {
                if (BackpressureHelper.add(this, n) == 0L) {
                    if (n == Long.MAX_VALUE) {
                        fastPath();
                    } else {
                        slowPath(n);
                    }
                }
            }
        }

进入 fastPath

        @Override
        void fastPath() {
            int f = end;
            ConditionalSubscriber<? super Integer> a = downstream;

            for (int i = index; i != f; i++) {
                if (cancelled) {
                    return;
                }
                a.tryOnNext(i);
            }
            if (cancelled) {
                return;
            }
            a.onComplete();
        }

从 start 到 start + end 遍历调用 a.tryOnNext(i) 发射，a 是 downstream，这里是 MapConditionalSubscriber

        @Override
        public boolean tryOnNext(T t) {
            if (done) {
                return false;
            }

            U v;

            try {
                v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
            } catch (Throwable ex) {
                fail(ex);
                return true;
            }
            return downstream.tryOnNext(v);
        }

调用 mapper.apply(t) 即我们的  it * it  方法，之后继续 downstream.tryOnNext(v)，这里自然是 FilterSubscriber 了

        @Override
        public boolean tryOnNext(T t) {
            if (done) {
                return false;
            }
            if (sourceMode != NONE) {
                downstream.onNext(null);
                return true;
            }
            boolean b;
            try {
                b = filter.test(t);
            } catch (Throwable e) {
                fail(e);
                return true;
            }
            if (b) {
                downstream.onNext(t);
            }
            return b;
        }

调用  filter.test(t)   即我们的 it % 3 == 0 ，条件正确 downstream.onNext(t)，此处 downstream 即 LambdaSubscriber。

    @Override
    public void onNext(T t) {
        if (!isDisposed()) {
            try {
                onNext.accept(t);
            } catch (Throwable e) {
                Exceptions.throwIfFatal(e);
                get().cancel();
                onError(e);
            }
        }
    }

onNext 是我们传入的 Consumer，到此完毕

由这两篇我们看到，一般情况下直接去看操作符中转换出的 Flowable 的子类的 subscribeActual ，这里连续订阅。而在它的内部类中 onSubscribe 转换。订阅自下而上，发射由上到下。

rx 中太多操作符，不懂得就可以直接去源码阅读。不要害怕，越好的框架越好阅读。