要理解RxJava框架,就需要理清楚其链路是怎样形成的。
先看一段简单的代码:
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
emitter.onNext("hello");
}
}).subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
System.out.println("result:"+s);
}
});
打印出来的结果:
result:hello
我们先来分析一下其中的observable链:
public abstract class Observable<T> implements ObservableSource<T> {
Observable是一个抽象类,它实现了ObservableSource接口,也就说我们后面如果看到ObservableSource接口的实例,可以看作是Observable向上转型的实例。
public interface ObservableSource<T> {
/**
* Subscribes the given Observer to this ObservableSource instance.
* @param observer the Observer, not null
* @throws NullPointerException if {@code observer} is null
*/
void subscribe(@NonNull Observer<? super T> observer);
}
在Observable create的过程:
public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
...
return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
}
先不看RxJavaPlugins中的内容,调用者只需要传入一个ObservableOnSubscribe的实现类,RxJava会将其以构造函数参数的形式传入,并封装构造一个ObservableCreate对象。ObservableCreate不再是一个抽象类,而且继承了Observable对象。
public final class ObservableCreate<T> extends Observable<T> {
final ObservableOnSubscribe<T> source;
public ObservableCreate(ObservableOnSubscribe<T> source) {
this.source = source;
}
...
于是这个时候,我们构造出了一个具体的Observable实例。
Observable抽象类,中只有一个方法是抽象的。
protected abstract void subscribeActual(Observer<? super T> observer);
所以,每个Observable子类实例化过程中,都需要实现subscribeActual方法。
回到之前的问题,Observable在链式调用过程中是怎样形成Observable链的呢?
我们接着看源码,得到ObservableCreate实例后,构建了一个单一入参的Consumer对象,并调用了subcribe方法,跟进去看一下:
public final Disposable subscribe(Consumer<? super T> onNext) {
return subscribe(onNext, Functions.ON_ERROR_MISSING, Functions.EMPTY_ACTION,
Functions.emptyConsumer());
}
继续跟:
public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
Action onComplete, Consumer<? super Disposable> onSubscribe) {
...
LambdaObserver<T> ls = new LambdaObserver<T>(onNext, onError, onComplete, onSubscribe);
subscribe(ls);
return ls;
}
LambdaObserver同样地,以构造函数的方式将Consumer对象封装到了Observer中,这样让调用者用很简洁的代码构造出一个Observer
public final void subscribe(Observer<? super T> observer) {
...
try {
...
subscribeActual(observer);
} catch (NullPointerException e) { // NOPMD
...
}
}
最后,发现subscribe调用的是Observable的实现类中的subscribeActual()方法。我们来看看之前的Observable子类ObservableCreate是如何实现subscribeActual方法的:
@Override
protected void subscribeActual(Observer<? super T> observer) {
CreateEmitter<T> parent = new CreateEmitter<T>(observer);
observer.onSubscribe(parent);
try {
source.subscribe(parent);
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
parent.onError(ex);
}
}
看到这里有个source.subscribe(),于是直接调用了我们传入的接口ObservableOnSubscribe实例中的subscribe方法。
因为我们这里只有一个Observable,所以还没有看到链,没关系,先走一遍,后面再加入几个Observable再瞧瞧。
source.subscribe()后,由于我们在subscribe方法中执行了emitter的onNext()方法,所以,consumer收到了具体的消息。
Emitter是个什么东东?什么时候传给subscribe()方法?
之前讲到Consumer被封装到了一个lambdaObserver中,现在传了进来,并且以构造函数的方式传到CreateEmitter中,这种构造类的方式好眼熟啊,在哪儿看到过?
try {
InputStream stream = new BufferedInputStream(new FileInputStream(new
File("//abc")));
...
} catch (FileNotFoundException e) {
e.printStackTrace();
} finally{
...
}
装饰者模式。ContextWrapper和ContextImpl也比较类似。
这里Emitter把Observer作为入参传进来
static final class CreateEmitter<T>
extends AtomicReference<Disposable>
implements ObservableEmitter<T>, Disposable {
private static final long serialVersionUID = -3434801548987643227L;
final Observer<? super T> observer;
CreateEmitter(Observer<? super T> observer) {
this.observer = observer;
}
@Override
public void onNext(T t) {
if (t == null) {
onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
return;
}
if (!isDisposed()) {
observer.onNext(t);
}
}
@Override
public void onError(Throwable t) {
...
}
@Override
public boolean tryOnError(Throwable t) {
...
}
@Override
public void onComplete() {
...
}
@Override
public void setDisposable(Disposable d) {
...
}
...
}
可以看到起对onNext()方法进行了增强,添加了异常处理,disposable中断,最后还是调用了observer的onNext()方法。然而CreateEmitter与Observer之间并没有相同的父类,虽然有同样名称的方法。所以此处并非装饰者模式。
在emitter中调用了observer的OnNext(),于是lambdaObserver收到了onNext()回来的数据,
@Override
public void onNext(T t) {
if (!isDisposed()) {
try {
onNext.accept(t);
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
get().dispose();
onError(e);
}
}
}
lambdaObserver收到数据后,调用了Consumer的accept()方法,于是乎,我们最后成功在Consumer中打印到最后的字符串。
流程走了一遍。接下来,我们看,如果再加入几个Observable的转换后,多个Observable是如何形成链式关系了。
比如,我们把最开头的test1源码做一些修改:
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
emitter.onNext("hello");
}
}).map(new Function<String, String>() {
@Override
public String apply(String s) throws Exception {
return "abc-"+s;
}
}).map(new Function<String, String>() {
@Override
public String apply(String s) throws Exception {
return s+"-def";
}
}).subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
System.out.println("result:"+s);
}
});
再次插入两条map操作。
看看observable的静态方法map()都做了些什么:
public final <R> Observable<R> map(Function<? super T, ? extends R> mapper) {
ObjectHelper.requireNonNull(mapper, "mapper is null");
return RxJavaPlugins.onAssembly(new ObservableMap<T, R>(this, mapper));
}
似乎看到了一些细微的区别,我们来对比一下:
public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
ObjectHelper.requireNonNull(source, "source is null");
return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
}
create()的时候只有一个入参,而现在new ObservableMap()的时候有两个入参,除了Function()用来构造一个新的Observable外,还传入了一个this,把当前这个observable实例也传了进去。
传进去干嘛?
莫非这里就与链有关了?
public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {
final Function<? super T, ? extends U> function;
public ObservableMap(ObservableSource<T> source, Function<? super T, ? extends U> function) {
super(source);
this.function = function;
}
...
只看到source传了进来,没看到哪儿用到了啊?
只看到被父类的构造函数拿去用来。
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;
}
}
我们来分析一下父类,ObservableSource是干嘛?之间好像有讨论过,对不对?
抽象类Observable实现了ObservableSource,所以这里相当于向上转型了,也就说我在构造下一个mapObservable的时候,把上一个Observable存了起来,这不正是一个链表吗?
明白了吧。
接着分析下,加入map后,后面的subscribe()发生了一些怎样的变化,observer的链又是怎样形成的。
欲知后事如何,且看下回分解。