我们用Observable提供的静态方法just来写一个简单的列子
Observable.just(1).subscribe(object: Observer{
override fun onComplete() {
Log.d(Constants.TAG, "rx -- onComplete")
}
override fun onSubscribe(d: Disposable) {
Log.d(Constants.TAG, "rx -- onSubscribe")
}
override fun onNext(t: Int) {
Log.d(Constants.TAG, "rx -- onNext --$t")
}
override fun onError(e: Throwable) {
Log.d(Constants.TAG, "rx -- onError")
}
})
打印结果
D/cat: rx -- onSubscribe
D/cat: rx -- onNext --1
D/cat: rx -- onComplete
RxJava采用观察者模式实现的,我们知道简单的观察者模式,一定是可观察者(Observable)发生变化,触发观察者(Observer)的方法,实现实时监听
那么问题来了,仅仅一个
just
方法,如何实现触发操作的呢?
我们来看源码
public static Observable just(T item) {
ObjectHelper.requireNonNull(item, "The item is null");
return RxJavaPlugins.onAssembly(new ObservableJust(item));
}
比较重要是创建了ObservableJust
实例,ObservableJust是Observable的实例类
public final class ObservableJust extends Observable implements ScalarCallable {
private final T value;
public ObservableJust(final T value) {
this.value = value;
}
@Override
protected void subscribeActual(Observer super T> observer) {
ScalarDisposable sd = new ScalarDisposable(observer, value);
observer.onSubscribe(sd);
sd.run();
}
@Override
public T call() {
return value;
}
}
看到这,可能也没有明白,构造方法只是传入个一个value值,还是没有讲解到如何触发。
我们先去看下Observable的subscribe方法,代码最终执行
public final void subscribe(Observer super T> observer) {
ObjectHelper.requireNonNull(observer, "observer is null");
try {
observer = RxJavaPlugins.onSubscribe(this, observer);
...
subscribeActual(observer);
} catch (NullPointerException e) { // NOPMD
throw e;
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
// can't call onError because no way to know if a Disposable has been set or not
// can't call onSubscribe because the call might have set a Subscription already
RxJavaPlugins.onError(e);
NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
npe.initCause(e);
throw npe;
}
}
从上面可以看到最终会调用subscribeActual
方法。
再来分析subscribeActual
方法
@Override
protected void subscribeActual(Observer super T> observer) {
ScalarDisposable sd = new ScalarDisposable(observer, value);
// 会执行到 onSubscribe()方法
observer.onSubscribe(sd);
// next complete方法会在这里执行
sd.run();
}
这个ScalarDisposable又是什么呢?
Represents a Disposable that signals one onNext followed by an onComplete.
@Override
public void run() {
if (get() == START && compareAndSet(START, ON_NEXT)) {
// 执行onNext()方法
observer.onNext(value);
if (get() == ON_NEXT) {
lazySet(ON_COMPLETE);
执行onComplete()方法
observer.onComplete();
}
}
}
从整个流程可以看到,当我们Observer订阅了Observable之后,才会触发Observable产出数据,进而触发Observer的监听方法。