源码解析RxBus实现观察者模式

一句话描述RxJava实现观察者模式的过程

  • 事件从Observable中发出,在Observer中接收并由Observer处理

RxJava实现观察者模式:四个基本概念,三个步骤

四个基本概念:

  • Observable
  • Observer
  • subscribe
  • 事件

三个步骤:

  • 创建Observer
  • 创建Observable
  • subscribe(订阅)

接下来逐步解析每一个过程

Observer创建

Observer observer = new Observer() {
@Override
 public void onCompleted() {

 }

 @Override
 public void onError(Throwable e) {

 }


 @Override
 public void onNext(Object o) {

 }
 };





也可以用Subscriber,这里先以Observer为例进行说明。
中规中矩的创建方式,并没什么新奇,神奇的地方在Observable。

Observable的创建

Observable observable = Observable.create(new Observable.OnSubscribe<String>() {

@Override
 public void call(Subscriber<? super String> subscriber) {

subscriber.onNext("");

subscriber.onCompleted();

subscriber.onError(new Throwable());


}
});


我们看一下Observable.create 方法

public static <T> Observable<T> create(OnSubscribe<T> f) {

return new Observable<T>(hook.onCreate(f));
}

  • 可以看出,内部调用了new方法新建了一个对象,这一步看上去没什么神奇,实际上也确实不神奇。神奇的是传入了一个Observable.OnSubscribe接口实现作为入参。
接下来就让我们看一下神奇的Observable.OnSubscribe

public interface OnSubscribe<T> extends Action1<Subscriber<? super T>> {

// cover for generics insanity

}

# OnSubscribe继承自Action1,我们来看一下Action1的定义

public interface Action1<T> extends Action {

void call(T t);

}

那么我们写出OnSubscribe的完整定义

public interface OnSubscribe<T> extends Action1<Subscriber<? super T>> {
void call(Subscriber<? super T> subscriber);

}

我们一般在OnSubscribe的call方法中调用subscriber中的方法。也就是说,我们在OnSubscribe的call方法中调用了哪个 subscriber,哪个subscriber的方法会触发。而我们所希望的是,这里作为参数传递过来的subscriber是我们在第一步中创建出来的observer,因为如果真是这样的话,我们观察者模式就可以串起来了。

那么作为参数传入的subscriber究竟是谁呢?而call方法是什么时候调用的呢?

为了搞清楚这个问题,我们来看一下RxJava实现观察者模式的第三步(最后一步)

subscribe(订阅)

observable.subscribe(observer);
看observable.subscribe源码:

public final Subscription subscribe(final Observer<? super T> observer) {

if (observer instanceof Subscriber) {

return subscribe((Subscriber<? super T>)observer);

}

return subscribe(new ObserverSubscriber<T>(observer));

}

这段代码比较有意思,如果传入的参数是Subscriber,则调用

public final Subscription subscribe(Subscriber<? super T> subscriber) {

return Observable.subscribe(subscriber, this);

}

否则将传入的observer包装成了Subscriber,调用上述方法。

而上面的方法仅调用了subscribe(Subscriber

为了更清楚的看清其中的逻辑,这里只保留了逻辑相关的代码

static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T> observable) {

……….
try {

// allow the hook to intercept and/or decorate

hook.onSubscribeStart(observable, observable.onSubscribe).call(subscriber);
-------------------------------

return hook.onSubscribeReturn(subscriber);

} catch (Throwable e) {

……
return Subscriptions.unsubscribed();

}
}

这里的subscriber实际上(直接或间接)就是observer

看分割线上面那行代码:
参考这个hook.onSubscribeStart

public <T> OnSubscribe<T> onSubscribeStart(Observable<? extends T> observableInstance, final OnSubscribe<T> onSubscribe) {

// pass through by default

return onSubscribe;

}

我们可以把那行代码写成这样
`onSubscribe.call(subscriber);`
也就是说,在subscribe方法中,调用了
`onSubscribe.call(subscriber);`

总结

到这里,就完全通顺下来了。

  • 第一步 创建Observer
  • 第二步 Observable 创建实例,并通过Observable的create持有OnSubscribe
  • 第三步 Observable subscribe方法,通过调用第二步传入的OnSubscribe的call方法,间接调用第一步产生的observer中的方法

最后借用睿智的狄公的一句话结尾:事情的经过就是这个样子的。

©️2020 CSDN 皮肤主题: 大白 设计师: CSDN官方博客 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值