一个使用Rxjava的开源项目
一个简单的例子
Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter emitter) throws Exception {
emitter.onNext("Android");
emitter.onNext("ios");
emitter.onNext("Other");
emitter.onComplete();
}
})
.subscribe(new Observer() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(String s) {
Log.d(TAG, "onNext: "+s);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
从create开始
public static Observable create(ObservableOnSubscribe source) {
ObjectHelper.requireNonNull(source, "source is null");
return RxJavaPlugins.onAssembly(new ObservableCreate(source));
}
返回值是 Observable,参数是 ObservableOnSubscribe ,定义如下：
public interface ObservableOnSubscribe {
void subscribe(ObservableEmitter e) throws Exception;
}
ObservableOnSubscribe 是一个接口，里面就一个方法,也是我们实现的那个方法：该方法的参数是 ObservableEmitter，它是关联起 Disposable 概念的一层：
public interface ObservableEmitter extends Emitter {
void setDisposable(Disposable d);
void setCancellable(Cancellable c);
boolean isDisposed();
ObservableEmitter serialize();
}
ObservableEmitter 也是一个接口。里面方法很多，它继承了 Emitter
public interface Emitter {
void onNext(T value);
void onError(Throwable error);
void onComplete();
}
Emitter
ObservableCreate 算是一种适配器的体现，create()需要返回的是 Observable,而我现在有的是（即 方法传入的参数）ObservableOnSubscribe 对象，ObservableCreate
将 ObservableOnSubscribe 适配成 Observable。 其中 subscribeActual()方法表示的是被订阅时真正被执行的方法。
public final class ObservableCreate extends Observable {
final ObservableOnSubscribe source;
public ObservableCreate(ObservableOnSubscribe source) {
this.source = source;
}
@Override
protected void subscribeActual(Observer observer) {
CreateEmitter parent = new CreateEmitter(observer);
observer.onSubscribe(parent);
try {
source.subscribe(parent);
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
parent.onError(ex);
}
}
OK,至此，创建流程结束，我们得到了 Observable
到 subscribe 结束
上面在代码在 create，返回 ObservableCreate 对象，然后调用该对象的 subscribe 完成订阅，我们知道 ObservableCreate 继承 Observable，
当调用 subscribe 方法时，会调 Observable 的 subscribe 方法：
public final void subscribe(Observer observer) {
...
// 真正的订阅处
subscribeActual(observer);
...
}
上面代码的 subscribeActual 调用的是 ObservableCreate 中的方法。
@Override
protected void subscribeActual(Observer observer) {
//1 创建 CreateEmitter，也是一个适配器，可以将 Observer -> Disposable，CreateEmitter 中主要持有 observer 对象的引用，并且维护了 dispose 变量。
CreateEmitter parent = new CreateEmitter(observer);
//2 onSubscribe（）参数是 Disposable。还有一点要注意的是 onSubscribe() 是在我们执行 subscribe() 这句代码的那个线程回调的，并不受线程调度影响。
// 给 observer 的一个回调，告诉它是否 dispose
observer.onSubscribe(parent);
try {
//3 将 ObservableOnSubscribe（源头）与 CreateEmitter（Observer，终点）联系起来，即完成订阅，此时 ObservableOnSubscribe 会向 observer 传送事件
source.subscribe(parent);
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
parent.onError(ex);
}
}
source 即 ObservableOnSubscribe 对象，在本文中是：
new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter emitter) throws Exception {
emitter.onNext("Android");
emitter.onNext("ios");
emitter.onNext("Other");
emitter.onComplete();
}
}
ObservableOnSubscribe#subscribe 中会调用 parent.onNext() 和 parent.onComplete()，parent 是 CreateEmitter 对象，如下：
@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;
}
//如果没有被 dispose，会调用 Observer 的 onNext()方法
if (!isDisposed()) {
observer.onNext(t);
}
}
@Override
public void onError(Throwable t) {
if (!tryOnError(t)) {
RxJavaPlugins.onError(t);
}
}
@Override
public void onComplete() {
if (!isDisposed()) {
try {
observer.onComplete();
} finally {
dispose();
}
}
}
总结
Observable 和 Observer 的关系没有被 dispose，才会回调 Observer 的 onXXXX()方法
Observer 的 onComplete() 和 onError() 互斥只能执行一次，因为 CreateEmitter 在回调他们两中任意一个后，都会自动dispose()
Observable 和 Observer关联时（订阅时），Observable 才会开始发送数据
ObservableCreate 将 ObservableOnSubscribe(真正的源)->Observable
ObservableOnSubscribe(真正的源)需要的是发射器 ObservableEmitter
CreateEmitter 将 Observer->ObservableEmitter,同时它也是 Disposable
source.subscribe(parent)
这句代码执行时，才开始从发送 ObservableOnSubscribe 中利用 ObservableEmitter 发送数据给 Observer。即数据是从源头 push 给终点。
map操作符
Observable.create(new ObservableOnSubscribe() { // return ObservableCreate
@Override
public void subscribe(ObservableEmitter emitter) throws Exception {
emitter.onNext("Android");
emitter.onNext("ios");
emitter.onNext("Other");
emitter.onComplete();
}
})
.map(new Function() { // return ObservableMap, 并且ObservableMap持有对 ObservableSubscribeOn 的引用
@Override
public String apply(String s) {
return s+s;
}
})
.subscribe(new Observer() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(String s) {
Log.d(TAG, "onNext: "+s);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
我们看一下map函数的源码：
public final Observable map(Function mapper) {
ObjectHelper.requireNonNull(mapper, "mapper is null");
return RxJavaPlugins.onAssembly(new ObservableMap(this, mapper));
}
public final class ObservableMap extends AbstractObservableWithUpstream {
final Function function;
public ObservableMap(ObservableSource source, Function function) {
// super()将上游的Observable保存起来 ，用于subscribeActual()中用。
super(source);
// 将function变换函数类保存起来
this.function = function;
}
@Override
public void subscribeActual(Observer t) {
source.subscribe(new MapObserver(t, function));
}
ObservableMap 继承自 AbstractObservableWithUpstream,该类继承自 Observable，很简单，就是将上游的 ObservableSource 保存起来，做一次 wrapper，
所以它也算是装饰者模式的体现，如下:
abstract class AbstractObservableWithUpstream extends Observable implements HasUpstreamObservableSource {
// 将上游的 ObservableSource 保存起来
protected final ObservableSource source;
AbstractObservableWithUpstream(ObservableSource source) {
this.source = source;
}
@Override
public final ObservableSource source() {
return source;
}
}
关于 ObservableSource，代表了一个标准的无背压的源数据接口，可以被 Observer 消费（订阅），如下：
public interface ObservableSource {
void subscribe(Observer observer);
}
所有的 Observable 都已经实现了它,所以我们可以认为 Observable 和 ObservableSource 是相等的：
public abstract class Observable implements ObservableSource {
所以我们得到的 ObservableMap 对象也很简单，就是将上游的 Observable 和变换函数类Function保存起来。
Function的定义超级简单，就是一个接口，给我一个T，还你一个R。
public interface Function {
R apply(T t) throws Exception;
}
subscribeActual()是订阅真正发生的地方，就是用 MapObserver 订阅上游 Observable。
@Override
public void subscribeActual(Observer t) {
//用 MapObserver 订阅上游 Observable。
source.subscribe(new MapObserver(t, function));
}
MapObserver 也是装饰者模式，对终点（下游）Observer修饰。
static final class MapObserver extends BasicFuseableObserver {
final Function mapper;
MapObserver(Observer actual, Function mapper) {
// super()将actual保存起来
super(actual);
// 保存Function变量
this.mapper = mapper;
}
@Override
public void onNext(T t) {
//done在onError 和 onComplete以后才会是true，默认这里是false，所以跳过
if (done) {
return;
}
//默认sourceMode是0，所以跳过
if (sourceMode != NONE) {
downstream.onNext(null);
return;
}
U v;
try {
//这一步执行变换,将上游传过来的 T，利用 Function 转换成下游需要的 V
v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
} catch (Throwable ex) {
fail(ex);
return;
}
//变换后传递给下游Observer
downstream.onNext(v);
}
@Override
public int requestFusion(int mode) {
return transitiveBoundaryFusion(mode);
}
@Nullable
@Override
public U poll() throws Exception {
T t = qd.poll();
return t != null ? ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.") : null;
}
}
订阅的过程，是从下游到上游依次订阅的:
即终点 Observer 订阅了 map 返回的 ObservableMap
然后 map 的 Observable(ObservableMap)在被订阅时，会订阅其内部保存上游 Observable，用于订阅上游的 Observer 是一个装饰者(MapObserver)，
内部保存了下游（本例是终点）Observer，以便上游发送数据过来时，能传递给下游。以此类推，直到源头 Observable 被订阅，它开始向 Observer 发送数据。数据传递的过程，当然是从上游push到下游的，
源头 Observable 传递数据给下游 Observer（本例就是MapObserver）,然后MapObserver接收到数据，对其变换操作后(实际的function在这一步执行)，
再调用内部保存的下游 Observer 的 onNext() 发送数据给下游,以此类推，直到终点 Observer 。