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()方法上。