最近在看给Android开发者的RxJava详解这篇文章,前面的都能理解,看到变换的原理——lift()这块的时候,我的脑袋直接懵逼了,每个单词我都认识,都能理解,但是连起来就看晕了,因此我花费了一些时间自行阅读源码来理解lift的原理,通过本篇文章记录一下,怕以后又给忘记了(大概率)。
首先我们来的看一个简单的rxjava的demo:
Observable.create(new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> subscriber) {
subscriber.onNext("hello");
subscriber.onNext(",");
subscriber.onNext("world!");
subscriber.onCompleted();
}
}).subscribe(new Subscriber<String>() {
@Override
public void onCompleted() {
LogUtils.i("onCompleted");
}
@Override
public void onError(Throwable throwable) {
LogUtils.i("onError");
}
@Override
public void onNext(String string) {
LogUtils.i(string);
}
})
相信不少新童鞋刚开始看到这些单词的时候有点晕乎乎的,Observable不是被观察者吗,怎么反而订阅了观察者Observer呢?其实可以简单的换个概念,Observable可以看成一个view,Subscriber看成OnClickListener,subscribe()订阅方法看成setOnClickListener(吐槽一下,这个subscribe如果命名成setOnSubscriber好理解很多)。进入subscribe()源码:
static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T> observable) {
if(subscriber == null) {
throw new IllegalArgumentException("observer can not be null");
} else if(observable.onSubscribe == null) {
throw new IllegalStateException("onSubscribe function can not be null.");
} else {
((Subscriber)subscriber).onStart();
if(!(subscriber instanceof SafeSubscriber)) {
subscriber = new SafeSubscriber((Subscriber)subscriber);
}
try {
hook.onSubscribeStart(observable, observable.onSubscribe).call(subscriber);
return hook.onSubscribeReturn((Subscription)subscriber);
} catch (Throwable var6) {
Throwable e = var6;
Exceptions.throwIfFatal(var6);
if(((Subscriber)subscriber).isUnsubscribed()) {
RxJavaPluginUtils.handleException(hook.onSubscribeError(var6));
} else {
try {
((Subscriber)subscriber).onError(hook.onSubscribeError(e));
} catch (Throwable var5) {
Exceptions.throwIfFatal(var5);
RuntimeException r = new OnErrorFailedException("Error occurred attempting to subscribe [" + var6.getMessage() + "] and then again while trying to pass to onError.", var5);
hook.onSubscribeError(r);
throw r;
}
}
return Subscriptions.unsubscribed();
}
}
}
这段代码里咱们需要关注的只有两行,首先在订阅的时候调用了subscriber.onStart()方法(所以如果有UI的操作如显示progressDialog不能放在onStart,因为它跟订阅处在一个线程里,应该放到doOnSubscribe()),然后调用了onSubscribe.call(),这个就是最开始create传进来的onSubscribe对象。
至此,rxjava发送事件逻辑咱们就弄清楚了,接下来看lift究竟是如何将事件进行变换的。以下代码中,使用lift方法将string事件变换成integer事件:
Observable.create(new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> subscriber) {
String s1 = "11";
String s2 = "22";
LogUtils.e("发送字符串事件:" + s1);
subscriber.onNext(s1);
LogUtils.e("发送字符串事件:" + s2);
subscriber.onNext(s2);
subscriber.onCompleted();
}
}).lift(new Observable.Operator<Integer, String>() {
@Override
public Subscriber<? super String> call(final Subscriber<? super Integer> subscriber) {
return new Subscriber<String>() {
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable throwable) {
}
@Override
public void onNext(String s) {
subscriber.onNext(Integer.valueOf(s));
}
};
}
}).subscribe(new Subscriber<Integer>() {
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable throwable) {
}
@Override
public void onNext(Integer integer) {
LogUtils.e("收到数据:" + integer);
}
});
按前面的demo,咱们的OnSubscribe发送的事件类型是String,为何在subscriber中接收到的却是integer对象呢?我们看一下lift方法里到底做了什么:
public final <R> Observable<R> lift(Observable.Operator<? extends R, ? super T> operator) {
return new Observable(new OnSubscribeLift(this.onSubscribe, operator));
}
只有简简单单的一行代码,新建了一个Obsevable对象,并且参数为一个新的OnSubscriberLift(继承OnSubscribe)对象。
PS:为方便读者理解,这里定义:
1、create返回的为observable1,lift返回的为observable2
2、create中传入的为onSubscribe1,lift中新建的为onSubscribe2
3、subscribe()中传入的为subsribe1,operator返回的为subscribe2
来看看这个类里到底做了啥:
public final class OnSubscribeLift<T, R> implements OnSubscribe<R> {
static final RxJavaObservableExecutionHook hook = RxJavaPlugins.getInstance().getObservableExecutionHook();
final OnSubscribe<T> parent;
final Operator<? extends R, ? super T> operator;
public OnSubscribeLift(OnSubscribe<T> parent, Operator<? extends R, ? super T> operator) {
this.parent = parent;
this.operator = operator;
}
public void call(Subscriber<? super R> o) {
try {
Subscriber st = (Subscriber)hook.onLift(this.operator).call(o);
try {
st.onStart();
this.parent.call(st);
} catch (Throwable var4) {
Exceptions.throwIfFatal(var4);
st.onError(var4);
}
} catch (Throwable var5) {
Exceptions.throwIfFatal(var5);
o.onError(var5);
}
}
}
根据前面分析,subscribe()方法会调用到onSubscribe.call,所以这里是subscribe1.subscribe() -> observable2.onSubscribe2.call,也就是走到上面的代码,
new Observable(new OnSubscribeLift(this.onSubscribe, operator));
这个parent就是我们传入的this.onSubscribe,也就是onSubscribe1,它的call传入了一个st,这个st就是operator.call返回的subscriber对象。对,就是前面那个new出来的subscriber2。所以onSubscribe1.call - > subscriber2.onNext,而subscriber2.onNext里,我们写了一行这样的代码
subscriber.onNext(Integer.valueOf(s));
这样subscriber到底是不是我们要的subscriber1呢?是不是感到很激动,最终的答案就要揭晓了。没错,operator.call()方法里,传入了一个subscriber参数o,这个o正是demo里咱们调用subscribe()方法时传进来的subscriber对象,也就是subscriber1,看上图代码可以知道,最终经过转换传回给了subscriber1。流程图如下图所示:
由图不难分析,lift方法相当于给原本的Observable加了一层代理,subscriber不能直接访问到onSubscribe,必须由lift()中间做一层事件的处理转换。