最近可能是比较忙吧,很多事很麻烦,搞得蛮烦躁的。周末才有点时间看看书,写写东西,中午骑车时还把脚给摔伤了,哎,命苦啊。前端时间写了关于RxJava的一些操作符,那么今天就来看看源码,试着去看RxJava的内部实现过程吧。这次我觉得不会写很多,就一个方法:
Observable.create(new OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> observer) {
try {
if(!observer.isUnsubscribed()) {
observer.onNext("onNext");
observer.onCompleted();
}
}catch(Exception e) {
e.printStackTrace();
}
}
}).subscribe(new Observer<String>() {
@Override
public void onCompleted() {
print("onCompleted");
}
@Override
public void onError(Throwable arg0) {
print("onError:" + arg0 );
}
@Override
public void onNext(String arg0) {
print("onNext:" + arg0);
}
}) ;
那么简化起来,就是下面这个了:
A.create(B).subscribe(C) ;
其中A为Observable,即可观察类;
B为OnSubscribe,即观察者对象作为参数;
C为Observer,即为我们的观察者。
那么来看A.create(new B)源代码:
可以看出,create是静态方法,返回是一个新的Observable对象,那么现在还看看RxJavaHooks.onCreate(f)返回的是什么吧:
这里面有一个onObservableCreate对象,是静态的,在static静态代码块里面初始化,我们找到它:
那现在来看看
return RxJavaPlugins.getInstance().getObservableExecutionHook().onCreate(f);
返回的是什么吧:
看样子是返回了自己啊,那再回到onCreate方法中:
Func1<Observable.OnSubscribe, Observable.OnSubscribe> f = onObservableCreate;
if (f != null) {
return f.call(onSubscribe);
}
return onSubscribe;
此时return f.call(onSubcribe) -> 以为着 return onSubcribe()它自己本身。
那么此时我们Observable.oncreate方法可以简写为:
public static <T> Observable<T> create(OnSubscribe<T> f) {
return new Observable<T>(f);
}
好了,create方法搞定了,现在来看Observable.create().subscribe()中的subscribe方法:
我们先考虑最简单的,现在返回的是重载的subscribe方法。在这之前,我们先看一下ObserverSubscriber这个类:
public final class ObserverSubscriber<T> extends Subscriber<T> {
final Observer<? super T> observer;
public ObserverSubscriber(Observer<? super T> observer) {
this.observer = observer;
}
@Override
public void onNext(T t) {
observer.onNext(t);
}
@Override
public void onError(Throwable e) {
observer.onError(e);
}
@Override
public void onCompleted() {
observer.onCompleted();
}
}
可以看出,这个ObserverSubscriber内部做事的还是一个Observer,相当于Observer的包装类。
再来看subcribe方法:
此时返回的是一个静态方法,注意传入的参数,第一个ObserverSubscriber,也就相当于我们的Observer;第二个就是我们Observable本身。好了,那么就进入这里面去看看吧:【代码经过精简】
static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T> observable) {
subscriber.onStart();
try {
RxJavaHooks.onObservableStart(observable, observable.onSubscribe).call(subscriber);
return RxJavaHooks.onObservableReturn(subscriber);
} catch (Throwable e) {
if (subscriber.isUnsubscribed()) {
RxJavaHooks.onError(RxJavaHooks.onObservableError(e));
} else {
try {
subscriber.onError(RxJavaHooks.onObservableError(e));
} catch (Throwable e2) {
Exceptions.throwIfFatal(e2);
RuntimeException r = new OnErrorFailedException("Error occurred attempting to subscribe");
RxJavaHooks.onObservableError(r);
throw r; // NOPMD
}
}
return Subscriptions.unsubscribed();
}
}
还是按照最简单的方案进行下去,看这个最重要的一句话:
RxJavaHooks.onObservableStart(observable, observable.onSubscribe).call(subscriber);
首先我们需要分清楚三个参数的含义:
第一个是就是我们设置的A,也就是上文传入的this,也就是create方法中new的那个Observable;
第二个Observable.onSubcribe就是我们设置的B,也就是我们传入的OnSubscribe;
第三个subscriber就是我们设置的C,其实就是一个Observer,它来自我们subscribe绑定的元素
来看方法的实现:
此时我们像上次那样,查看onObservableStart的实现方式:
然后直接看onSubscribeStart(t1,t2),前面的getObservableExecutionHook()相当于单例模式获取RxJavaPlugins的,所以就没什么好说的啊,来看onSubscribeStart:
看到没有,返回的是第二个参数,什么都没有改变,返回就是onSubscribe,那么就是说:
RxJavaHooks.onObservableStart(observable, observable.onSubscribe).call(subscriber);
--->
observable.onSubscribe.call(subscriber);
--->
C.call(subscriber)
--->
public void call(Subscriber<? super String> observer) {
try {
if(!observer.isUnsubscribed()) {
observer.onNext("onNext");
observer.onCompleted();
}
}catch(Exception e) {
e.printStackTrace();
}
}
好了,终于走通了,我们的程序终于大白天下了,也终于知道为啥我们这么写,可以执行onNext,onCompleted方法了。
执行完成之后,会返回一个订阅对象,即Subscription对象
return RxJavaHooks.onObservableReturn(subscriber);
当然了,在程序执行的过程中,如果遇到错误,会调用:
subscriber.onError(RxJavaHooks.onObservableError(e));
进行接收。当然,并不是所有的error都能接接收,这里的原因很简单,有可能是使用者在使用过程中用了非法的函数方式操作造成的,所以有些错误使我们不能接收的。
当然了,写到这里基本上把一个简单的RxJava过程从源码的角度看了一遍,当然里面有很多东西现在不是很懂,以后有时间慢慢研究吧。改睡觉了,明天又要上班了。