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

最新推荐文章于 2020-12-19 22:25:50 发布

vhawk

最新推荐文章于 2020-12-19 22:25:50 发布

阅读量953

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/vhawk/article/details/52238482

本文解析了RxJava中观察者模式的实现原理，详细介绍了四个核心概念：Observable、Observer、subscribe及事件，并通过三个步骤展示了如何使用这些概念来实现观察者模式。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一句话描述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;  }