一、RxJava
RxJava在事件的关联上采用了观察者模式的思路，区别于不同的观察者模式，它的订阅方式更像是被观察者指定观察者。参考文档的解释更为贴切，RxJava更像是上游发送事件给下游。
上游事件（被观察者的产生）
Obserable.create方法
1.onAssembly是一个hock方法，它内部的参数onObservableAssembly在使用其他操作符方法进行数据转换时，会被赋值（例如：map），在这里它是一个空对象 所有会直接返回source，也就是ObservableCreate
2.所以这里Observable相当于ObservableCreate
3.ObservableOnSubscribe source:相当于事件源，负责包裹事件
public static Observable create(ObservableOnSubscribe source) {
ObjectHelper.requireNonNull(source, "source is null");
return RxJavaPlugins.onAssembly(new ObservableCreate(source));
}
public static Observable onAssembly(@NonNull Observable source) {
Function f = onObservableAssembly;
if (f != null) {
return apply(f, source);
}
return source;
}
下游事件
1.创建下游事件/被观察者 只负责接收上游传递过来的数据，做其他业务逻辑
订阅事件
- hock住observer事件，并对接收的事件做一些转化。如果没有转化，直接返回observer对象
2.实际完成操作的是subscribeActual方法，这里相当于是调用ObservableCreate的subscribeActual方法
public final void subscribe(Observer observer) {
......
observer = RxJavaPlugins.onSubscribe(this, observer);
......
ObjectHelper.requireNonNull(observer, "Plugin returned null Observer");
......
subscribeActual(observer);
}
实际的上游输送事件对象ObservableCreate
1.它的subscribeActual在父类方法subscribe方法被调用后触发
2.首先会创建一个CreateEmitter对象负责传递数据，同时持有了观察者，也就是下游事件对象
3.直接调用下游事件的onSubscribe方法
4.调用事件源ObservableOnSubscribe的subscribe方法
5.触发subscribe方法后会在内部调用CreateEmitter的onNext、onComplete方法（由使用者决定）
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);
}
}
查看CreateEmitter代码
1.它的内部持有了observer对象
2.它的发送事件方法其实是在内部调用了observer对应的方法。这样参数就通过它传递给了observer对应的方法
static final class CreateEmitter extends AtomicReference
implements ObservableEmitter, Disposable {
final Observer 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;
}
...
observer.onNext(t);
...
}
@Override
public void onComplete() {
...
observer.onComplete();
...
}
}
}
三、简单事件下发的流程
在上下游管道调用subscribe方法后，下游管道observer被事件分发对象CreateEmitter拿到，并调用了事件分发对象的onNext，onComplete方法传递参数，而事件分发对象CreateEmitter对象的onNext，onComplete方法内部又调用了上游管道的对象对应的onNext，onComplete方法，完成了数据的传递
四、模拟简单事件的分发
1.上游事件，负责和下游事件建立联系
/**
* @author GUO on 2018/3/29.
* Email：[email protected]
* 上游管道
*/
public class Upper {
public EventSource source;
public Upper(EventSource source) {
this.source = source;
}
/**
* 连通管道
* @param receive
*/
public void connect(Receive receive) {
SendEvent sender = new SendEvent(receive);
source.subscribe(sender);
}
}
2.下游管道，负责接收上游传递的事件
/**
* @author GUO on 2018/3/29.
* Email：[email protected]
* 负责接收事件
*/
public interface Receive {
public void onReceive(int event);
public void onComplete();
}
3.事件源，负责包装事件
/**
* @author GUO on 2018/3/29.
* Email：[email protected]
* 事件源
*/
public interface EventSource {
void subscribe(SendEvent sender);
}
4.sendEvent负责发送事件
/**
* @author GUO on 2018/3/29.
* Email：[email protected]
* 负责发送事件,内部实际调用下游Receive方法
*/
public class SendEvent {
public Receive mReceive;
public SendEvent(Receive receive) {
this.mReceive = receive;
}
/**
* @param a
*/
public void onSend(int a) {
System.out.println("send event 发送事件");
mReceive.onReceive(a);
}
public void onComplete() {
mReceive.onComplete();
}
}
3.关联
Upper upper = new Upper(new EventSource() {
@Override
public void subscribe(SendEvent sender) {
int doSomething=1;
sender.onSend(doSomething);
sender.onComplete();
}
});
Receive receive = new Receive() {
@Override
public void onReceive(int event) {
System.out.println(" 收到事件 "+event);
}
@Override
public void onComplete() {
System.out.println(" 完成事件 ");
}
};
upper.connect(receive);