RxJava结合源码学习二

RxJava结合源码学习二

加深印象

1、首先我们先再理清下Observable和Subscriber通信的原理

• Observable* 被观察者
• Subscriber 订阅者
• OnSubscribe 被订阅者创建时实现的接口，用来被观察者发出请求给观察者

Observable 创建的时候需要实现一个 OnSubscribe 接口，实现其中的 call 方法，并在call里面指定订阅者需要执行的一系列方法，当有 Subscriber 订阅这个 Observable 时，就会执行call指定的一系列方法。

在复习了一遍通信原理之后，我们要开始学习RxJava的一些操作符了。

2、just 操作符，先看下如何使用的，这是just的其中一种情况 just(T value)：

Observable.just("NBA").subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.i(TAG, s);
            }
        });

接着我们从源码的角度分析，其如何实现的：

//Observable.java

public static <T> Observable<T> just(final T value) {
        return ScalarSynchronousObservable.create(value);
    }

//ScalarSynchronousObservable.java

public final class ScalarSynchronousObservable<T> extends Observable<T> {

    public static <T> ScalarSynchronousObservable<T> create(T t) {
            return new ScalarSynchronousObservable<T>(t);
        }

    protected ScalarSynchronousObservable(final T t) {
        super(hook.onCreate(new JustOnSubscribe<T>(t)));
        this.t = t;
    }

    static final class JustOnSubscribe<T> implements OnSubscribe<T> {
        final T value;

        JustOnSubscribe(T value) {
            this.value = value;
        }

        @Override
        public void call(Subscriber<? super T> s) {
            s.setProducer(createProducer(s, value));
        }
    }

    static <T> Producer createProducer(Subscriber<? super T> s, T v) {
        if (STRONG_MODE) {
            return new SingleProducer<T>(s, v);
        }
        return new WeakSingleProducer<T>(s, v);
    }
}

通过源码我们可以知道 Observable.just() 这个方法内部是生成了一个 ScalarSynchronousObservable，它是Observable的一个子类，create()的时候传入了一个OnSubscribe的实现类JustOnSubscribe，内部实现了call方法，call方法让Subscriber执行了setProducer(createProducer(s, value))。

这里我们再看下 createProducer(s, value) 源码

static <T> Producer createProducer(Subscriber<? super T> s, T v) {
        if (STRONG_MODE) {
            return new SingleProducer<T>(s, v);
        }
        return new WeakSingleProducer<T>(s, v);
    }

这里根据STRONG_MODE的true，false分两个Producer，我们分别简化两个类的源码

public final class SingleProducer<T> extends AtomicBoolean implements Producer {

    public SingleProducer(Subscriber<? super T> child, T value) {
        this.child = child;
        this.value = value;
    }

    @Override
    public void request(long n) {
        if (compareAndSet(false, true)) {
            final Subscriber<? super T> c = child;
            T v = value;
            c.onNext(v);
            c.onCompleted();
        }
    }
}

static final class WeakSingleProducer<T> implements Producer {
        public WeakSingleProducer(Subscriber<? super T> actual, T value) {
            this.actual = actual;
            this.value = value;
        }

        @Override
        public void request(long n) {
            Subscriber<? super T> a = actual;
            T v = value;
            a.onNext(v);
            a.onCompleted();
        }
    }

通过这两个Producer的实现类，可以知道他们在request方法调用了 Subscriber 的 onNext() 方法，并传入了我们 just 传入的T类型的值，这里是字符串”NBA”，最后调用了 Subscriber 的 onCompleted() 方法。这里涉及到Producer的知识，这个后面我们再深究。

总结：just这个操作符，相当于创建了一个Observable，并传入一个OnSubscribe，里面call方法通知Subscriber调用onNext()和onComplete()方法，其中Subscriber onNext(T)参数值是just传入的T类型的值。

3、from 操作符，先看下如何使用的，这个from使用的其中一种情况 from(T[] array)

Observable.from(sports).subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.i(TAG, s);
            }
        })

接着我们从源码的角度分析，其如何实现的：

public static <T> Observable<T> from(T[] array) {
        int n = array.length;
        if (n == 0) {
            return empty();
        } else
        if (n == 1) {
            return just(array[0]);
        }
        return create(new OnSubscribeFromArray<T>(array));
    }

通过源码可以知道，from操作符会先判断集合的长度，当长度等于0，则返回空的Observable；当只有一个值的时候，则会调用just操作符处理；当集合长度大于1的时候则会传入一个OnSubscribe的实现类OnSubscribeFromArray，接下来我们来看下该类简化的源码：

public final class OnSubscribeFromArray<T> implements OnSubscribe<T> {
    @Override
    public void call(Subscriber<? super T> child) {
        child.setProducer(new FromArrayProducer<T>(child, array));
    }

    static final class FromArrayProducer<T>
    extends AtomicLong
    implements Producer {
        final Subscriber<? super T> child;
        final T[] array;

        public FromArrayProducer(Subscriber<? super T> child, T[] array) {
            this.child = child;
            this.array = array;
        }

        @Override
        public void request(long n) {
            if (n < 0) {
                throw new IllegalArgumentException("n >= 0 required but it was " + n);
            }
            if (n == Long.MAX_VALUE) {
                if (BackpressureUtils.getAndAddRequest(this, n) == 0) {
                    fastPath();
                }
            } else
            if (n != 0) {
                if (BackpressureUtils.getAndAddRequest(this, n) == 0) {
                    slowPath(n);
                }
            }
        }

        void fastPath() {
            final Subscriber<? super T> child = this.child;

            for (T t : array) {
                child.onNext(t);
            }
            child.onCompleted();
        }

        void slowPath(long r) {
            final Subscriber<? super T> child = this.child;
            final T[] array = this.array;
            final int n = array.length;

            long e = 0L;
            int i = index;

            for (;;) {
                while (r != 0L && i != n) {
                    child.onNext(array[i]);

                    i++;

                    if (i == n) {
                        if (!child.isUnsubscribed()) {
                            child.onCompleted();
                        }
                        return;
                    }
                }
            }
        }
    }
}

通过源码可以知道这里在call方法里给Subscriber设置一个Producer的实现类FromArrayProducer。FromArrayProducer方法通过遍历数组将数组的每个值传入Subscriber的onNext()方法。至于这边fastPath()和slowPath()的具体区别，这个咱后续再讨论。

总结：from这个操作符，相当于创建了一个Observable，并传入一个OnSubscribe，里面call方法遍历传入的数组，将数组里的值一一发到Subscriber的onNext(T)方法中，最后调用onComplete()方法。

4、理解了just和from两个操作符的其中一种情况，我们还得看看他们使用的其他情况

public static <T> Observable<T> just(T t1, T t2) {
        return from((T[])new Object[] { t1, t2 });
    }

public static <T> Observable<T> just(T t1, T t2, T t3) {
    return from((T[])new Object[] { t1, t2, t3 });
    }
....

public static <T> Observable<T> from(Iterable<? extends T> iterable) {
        return create(new OnSubscribeFromIterable<T>(iterable));
    }

public static <T> Observable<T> from(Iterable<? extends T> iterable) {
        return create(new OnSubscribeFromIterable<T>(iterable));
    }

just操作符可以传入多个参数，当多个参数的时候，是通过from操作符来实现的；

from操作符可以传入Iterable类型的集合，其内部也是通过遍历集合，将值依次传到Subscriber的onNext()方法。from操作符还可以传入Future，这个还没完全懂，后面再补上。

5、range 操作符，我们先看下用法：

Observable.range(0, 10).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                Log.i(TAG, "" + integer);
            }
        });

这个操作符我们就不贴出源码了，range操作符，需要传入两个参数，一个star，一个count。其中start作为开始的值；而count，是从start开始连续的整数的数量。然后Observable会将这些数量的值依次发出到Subscriber的onNext()方法上。