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方法调用了 SubscriberonNext() 方法,并传入了我们 just 传入的T类型的值,这里是字符串”NBA”,最后调用了 SubscriberonCompleted() 方法。这里涉及到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()方法上。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值