框架思想
RxJava
其思想主要是串行一步步来，然后起点是观察者，重点是被观察者
从起点流向终点，中间可以被各种事件拦截，最终的终点只关心他的上一个事件
U行结构
先会走onSubscribe
特点
方便插拔，类似于拦截器，可以一层层通过map转换，比如我想要给bitmap加水印，加一个map转换就行
防抖
感觉RxView throttleFirst 防抖，就是设置定时，如果当前还没有执行dispose方法，就吧新来执行dispose()方法
api
map 修改数据
flatmap 修改数据，并且返回的是被观察者<修改的数据>
donext,他和subscribe的区别是，doNext返回的是一个被观察者而不是dispose，所以他的连接不会断，可以继续请求下去，特别适合讲需要串行嵌套执行的网络请求整平
如何hook整个rxjava
rxjava其实无论你是create还是map，他是都创建了一个对象
public static Observable create(ObservableOnSubscribe source) {
ObjectHelper.requireNonNull(source, "source is null");
return RxJavaPlugins.onAssembly(new ObservableCreate(source));
}
@CheckReturnValue
@SchedulerSupport("none")
public final Observable map(Function mapper) {
ObjectHelper.requireNonNull(mapper, "mapper is null");
return RxJavaPlugins.onAssembly(new ObservableMap(this, mapper));
}
所有对象创建之前，都执行了 RxJavaPlugins.onAssembly的方法，这就是我们的hook点
@NonNull
public static Observable onAssembly(@NonNull Observable source) {
Function f = onObservableAssembly;
return f != null ? (Observable)apply(f, source) : source;
}
onObservableAssembly 默认为空，可以通过这个函数全局hook
public static void setOnObservableAssembly(@Nullable Function onObservableAssembly) {
if (lockdown) {
throw new IllegalStateException("Plugins can't be changed anymore");
} else {
RxJavaPlugins.onObservableAssembly = onObservableAssembly;
}
}
subscribe流程
当你调用被观察者（如ObservableCreate）.subscribe(一个观察者的时候) ，会执行被观察者的subscribeActual， 立刻执行观察者的onSubscribe,然后执行发射器Emitter，比如Emitter.next()
protected void subscribeActual(Observer observer) {
ObservableCreate.CreateEmitter parent = new ObservableCreate.CreateEmitter(observer);
observer.onSubscribe(parent);
try {
//source 就是 ObservableOnSubscribe ，我们被观察者create的时候需要new出来并通过他的参数调用其onNext
this.source.subscribe(parent);
} catch (Throwable var4) {
Exceptions.throwIfFatal(var4);
parent.onError(var4);
}
}
ObservableCreate.CreateEmitter 持有观察者
当你调用onNext的时候，
public void onNext(T t) {
if (t == null) {
this.onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
} else {
if (!this.isDisposed()) {
//调用观察者的onNext
this.observer.onNext(t);
}
}
}
整套流程就是。当你调用 subscribe , 传入观察者的时候，会先走被观察者的onSubscribe -> 观察者的onSubscribe方法 -> 再将观察者交与发射器，通过我们定义的发射器的onNext,走到被观察者的onNext
map流程，其实是rxjava最重要的流程和思想
1，未 subscribe 以前，装饰者模式，不断套 ObservableMap 类
@CheckReturnValue
@SchedulerSupport("none")
public final Observable map(Function mapper) {
ObjectHelper.requireNonNull(mapper, "mapper is null");
// this 为我们的上一个被观察者 ，等于我们新的被观察者持有老的被观察者，以及转换方法
return RxJavaPlugins.onAssembly(new ObservableMap(this, mapper));
}
2，一旦你调用了subscribe 订阅以后，就会掉到自身的subscribeActual，让我们看看ObservableMap 的subscribeActual
public void subscribeActual(Observer t) {
this.source.subscribe(new ObservableMap.MapObserver(t, this.function));
}
source是上一层的被观察者，我会调用上一层被观察者的subscribe ，传入的是被包裹的这一层观察者
让我们看一下MapObserver，当他被上一层掉起onNext的时候
public void onNext(T t) {
if (!this.done) {
if (this.sourceMode != 0) {
this.downstream.onNext((Object)null);
} else {
Object v;
try {
//生成新的结果v
v = ObjectHelper.requireNonNull(this.mapper.apply(t), "The mapper function returned a null value.");
} catch (Throwable var4) {
this.fail(var4);
return;
}
//downstream 就是传进来的下一任观察者
this.downstream.onNext(v);
}
}
}
总结步骤
1，一开始包裹的我们的被观察者 如 ObservableMap 包裹ObservableCreate
2，一旦发起订阅以后 开始给上一层一层一层通过MapObserver 包裹我们的观察者，比如最后的订阅类型是R类型，map前是T类型，这个MapObserver 就是还没执行map的apply函数的观察者，也就是上一层的观察者
3，上一层的观察者的发射器，调用onNext方法的时候，会执行MapObserver的onNext方法，会在里面执行apply方法 拿出下一层所有需要的数据R,并调用下一层观察者downstream的onNext方法
再捋一下
ObservableMap 持有上一层被观察者和转换函数，MapObserver 持有下一层观察者和转换函数
用我们可以理解的流程，最外层的 ObservableCreate
面试话语
我们的被观察者是Observable
当你调用 map方法的时候 原来的被观察者a 会被一个叫做ObservableMap的方法持有，同时他还持有转换函数，他是一个类型为R的Observable
当你调用subscribe 进行订阅的时候，会先走到ObservableMap subscribeActual方法。里面会将上一层被观察者Observable
使用的是一个叫 MapObsever