一、观察者模式
1.1、传统的观察者模式
1.2、RxJava 的观察者模式
- 区别
传统的观察者模式是一个 Obserable，多个 Observer。RxJava 的观察者模式是多个 Obserable，一个 Observer。
二、订阅的过程
我们以这段简单的代码为例：
Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(@NonNull ObservableEmitter emitter) throws Exception {
//发布事件
emitter.onNext(11);
emitter.onComplete();
}
}).subscribe(new Observer() {
@Override
public void onSubscribe(@NonNull Disposable d) {
//订阅
}
@Override
public void onNext(@NonNull Integer i) {
//处理接收事件
}
@Override
public void onError(@NonNull Throwable e) { }
@Override
public void onComplete() {}
});
}
大体流程是下面两张图
-
Observable 与 Observer 订阅的过程 重要步骤：
Observable 与 Observer 订阅的过程 -
Observable 与 Observer 订阅的过程 重要步骤(废弃)
Observable 与 Observer 订阅的过程
2.1、Observable创建过程
我们用Observable里面的 create 进行创建被观察者
Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(@NonNull ObservableEmitter emitter) throws Exception {
emitter.onNext(11);
emitter.onComplete();
}
})
public interface ObservableOnSubscribe {
void subscribe(@NonNull ObservableEmitter emitter) throws Exception;
}
由上我们可以得到在create 方法里面会创建一个ObservableOnSubscribe对象。
接下来我们看Observable#create方法：
public static Observable create(ObservableOnSubscribe source) {
ObjectHelper.requireNonNull(source, "source is null");
return RxJavaPlugins.onAssembly(new ObservableCreate(source));
}
上面的RxJavaPlugins.onAssembly()我们就不用讲了，其主要是用Hook技术，可以统计操作符使用的情况。见上节。
然后我们直接看ObservableCreate做什么事情：
public final class ObservableCreate extends Observable {
final ObservableOnSubscribe source;
public ObservableCreate(ObservableOnSubscribe source) {
//source 为 我们创建的 ObservableOnSubscribe
this.source = source;
}
...
}
ObservableCreate 里面主要做的是把 观察者 订阅后进行打包，处理后在出入 source 然后进行发送事件。具体过程见下：
2.2、Observable 与 Observer 订阅的过程
我们从Observer 的创建作为入口看：
new Observer() {
@Override
public void onSubscribe(@NonNull Disposable d) {}
@Override
public void onNext(@NonNull Integer i) {}
@Override
public void onError(@NonNull Throwable e) {}
@Override
public void onComplete() {}
}
我们调用subscribe订阅时，会把上面创建的 Observer 传进去
subscribe(new Observer() {
}
后执行到Observable#subscribe 方法
//参数 observer ，是我们上面创建的观察者
public final void subscribe(Observer observer) {
ObjectHelper.requireNonNull(observer, "observer is null");
try {
//校验
observer = RxJavaPlugins.onSubscribe(this, observer);
ObjectHelper.requireNonNull(observer, "Plugin returned null Observer");
//订阅观察者
subscribeActual(observer);
} catch (NullPointerException e) { // NOPMD
throw e;
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
RxJavaPlugins.onError(e);
NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
npe.initCause(e);
throw npe;
}
}
执行ObservableCreate#subscribeActual
@Override
protected void subscribeActual(Observer observer) {
//创建发射器，就是把 observer 包装了一层包袱
CreateEmitter parent = new CreateEmitter(observer);
//调用 Observer 里面的订阅 （onSubscribe）
observer.onSubscribe(parent);
try {
//source 为我们上面创建时传入的 ObservableOnSubscribe
// 回调到 创建obserable 里面的 `subscribe`
source.subscribe(parent);
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
parent.onError(ex);
}
}
ObservableCreate#CreateEmitter 把Observer 进行打包，当接收到Obserable 发送过来的事件时，并做相应的处理。
static final class CreateEmitter extends AtomicReference implements ObservableEmitter, Disposable {
//保证版本的一致性
private static final long serialVersionUID = -3434801548987643227L;
//我们上面创建的观察者
final Observer observer;
CreateEmitter(Observer observer) {
this.observer = observer;
}
@Override
public void onNext(T t) {
if (t == null) {
onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
return;
}
if (!isDisposed()) {
//返送事件
observer.onNext(t);
}
}
@Override
public void onError(Throwable t) {
if (!tryOnError(t)) {
RxJavaPlugins.onError(t);
}
}
@Override
public boolean tryOnError(Throwable t) {
if (t == null) {
t = new NullPointerException("onError called with null. Null values are generally not allowed in 2.x operators and sources.");
}
if (!isDisposed()) {
try {
observer.onError(t);
} finally {
dispose();
}
return true;
}
return false;
}
@Override
public void onComplete() {
if (!isDisposed()) {
try {
//完成事件
observer.onComplete();
} finally {
dispose();
}
}
}
@Override
public void setDisposable(Disposable d) {
DisposableHelper.set(this, d);
}
@Override
public void setCancellable(Cancellable c) {
setDisposable(new CancellableDisposable(c));
}
@Override
public ObservableEmitter serialize() {
return new SerializedEmitter(this);
}
@Override
public void dispose() {
DisposableHelper.dispose(this);
}
@Override
public boolean isDisposed() {
return DisposableHelper.isDisposed(get());
}
}
2.3、总结
整体流程图
由上图看RxJava订阅的过程是一个U 型结构
二、Map源码分析
执行过程
代码
Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(@NonNull ObservableEmitter emitter) throws Exception {
emitter.onNext(11);
emitter.onComplete();
}
}).map(new Function() {
@Override
public String apply(@NonNull Integer integer) throws Exception {
return "转换成字符串：" +integer;
}
}).subscribe(new Observer() {
@Override
public void onSubscribe(@NonNull Disposable d) { }
@Override
public void onNext(@NonNull String s) { }
@Override
public void onError(@NonNull Throwable e) { }
@Override
public void onComplete() { }
});
2.1、订阅的过程
订阅的过程按下面流程图分析：
- 我们跳过Observable 与 Observer 的创建过程直接分析 map 创建和订阅过程
.map(new Function() {
@Override
public String apply(@NonNull Integer integer) throws Exception {
return "转换成字符串：" +integer;
}
})
下面Function 的作用是把 入参 T ==> 返回值 R，也就是把integer ==> String类型。
public interface Function {
R apply(@NonNull T t) throws Exception;
}
执行 Observable#map 操作符：
public final Observable map(Function mapper) {
ObjectHelper.requireNonNull(mapper, "mapper is null");
// this : Observable
//mapper : 创建的Function对象
return RxJavaPlugins.onAssembly(new ObservableMap(this, mapper));
}
然后再ObservableMap里面对下游订阅的 Observer进行打包，并由Observable#subscribe方法jinxing处理
public final class ObservableMap extends AbstractObservableWithUpstream {
final Function function;
public ObservableMap(ObservableSource source, Function function) {
// source 指的是上游传过来的 observable
super(source);
this.function = function;
}
@Override
public void subscribeActual(Observer t) {
//t 是下游订阅的 observer
// 把 observer 打包到 MapObserver 中
// source.subscribe() 会调用 Observable 的 subscribe 方法进行上层的订阅
source.subscribe(new MapObserver(t, function));
}
static final class MapObserver extends BasicFuseableObserver {
final Function mapper;
MapObserver(Observer actual, Function mapper) {
super(actual);
this.mapper = mapper;
}
@Override
public void onNext(T t) {
if (done) {
return;
}
if (sourceMode != NONE) {
actual.onNext(null);
return;
}
U v;
try {
v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
} catch (Throwable ex) {
fail(ex);
return;
}
// 向下游发送事件
actual.onNext(v);
}
@Override
public int requestFusion(int mode) {
return transitiveBoundaryFusion(mode);
}
@Nullable
@Override
public U poll() throws Exception {
T t = qs.poll();
return t != null ? ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.") : null;
}
}
}
Observable#subscribe订阅处理
public final void subscribe(Observer observer) {
ObjectHelper.requireNonNull(observer, "observer is null");
try {
observer = RxJavaPlugins.onSubscribe(this, observer);
ObjectHelper.requireNonNull(observer, "Plugin returned null Observer");
subscribeActual(observer);
} catch (NullPointerException e) { // NOPMD
throw e;
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
RxJavaPlugins.onError(e);
NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
npe.initCause(e);
throw npe;
}
}
由MapObserver的父类BasicFuseableObserver里的onSubscribe方法处理订阅。
public final void onSubscribe(Disposable s) {
if (DisposableHelper.validate(this.s, s)) {
this.s = s;
if (s instanceof QueueDisposable) {
this.qs = (QueueDisposable)s;
}
if (beforeDownstream()) {
//订阅观察者
actual.onSubscribe(this);
afterDownstream();
}
}
}
下面是整体的简易图：
- 总结
由此可见RxJava的其他操作符和map的解析流程都是一样的，涉及到封包和拆包。
三、RxJava装饰模型
RxJava在执行订阅之前会利用装饰模型把Observable进行封包，封包如下图所示：
封包后，执行到底部。然后再执行订阅边拆前面的封包，然后重新对 Observer进行封包，最后发送消息时再次拆包，如下图所示：
时序图