(4.6.22)来吧,是时候撸一份自己的RxJava框架啦
链式调用实现原理: 观察者模式
1.1 控制器 持有 1个生产者 和 多个消费者
1.2 调用生产者的生产函数,并将多个消费者实例注入其中
设计思路
核心控制器
- 实现 注册事件生产者,并持有生产者实例
- 实现 添加事件的消费者,并持有消费者容器的实例
- 实现 开启整个事件流程,即调用生产者的事件函数,并将消费者们注入其中
生产者接口
- void call(消费者们){}
函数持有消费者实例,在适当时机,调用消费者实例的对应成员函数
- void call(消费者们){}
消费者接口
- onSuccess(T t);
t为生产者在call函数中注入的数据实例 - onError(Throwable throwable)
throwable为生产者在call函数中注入的数据实例
- onSuccess(T t);
实践
1. 发布者—被观察者 : 事件的产生者OnPublisher
/**
* 发布者---被观察者 : 事件的产生者
* Created by yhf on 16/12/18.
*/
public interface OnPublisher<T> {
public void call(OnObserver<T> observer);
}
2. 观察者—消费者: 事件的消费者OnObserver
/**
* 观察者---消费者: 事件的消费者
* Created by yhf on 16/12/18.
*/
public interface OnObserver<T> {
public void onSuccess(T t);
public void onError(Throwable throwable);
public void onFinished();
}
3. 核心控制器
/**
* 核心类:发布者---被观察者的 业务控制器
* - 实现 注册事件生产者,并持有生产者实例 create()
* - 实现 添加事件的消费者,并持有消费者容器的实例 bind()
* - 实现 开启整个事件流程,即调用生产者的事件函数,并将消费者们注入其中 post()
* Created by yhf on 16/12/16.
*/
public class Publisher<T> {
private OnPublisher<T> onPublisher;
private Vector<OnObserver<T>> onObservers;
public static <T> Publisher<T> getInstance(){
return new Publisher<T>();
}
private Publisher() {
onObservers = new Vector<OnObserver<T>>();
}
public Publisher<T> create(OnPublisher<T> publisher){
onPublisher = publisher;
return this;
}
public Publisher<T> bind(OnObserver<T> observer){
onObservers.add(observer);
return this;
}
public Publisher<T> post(){
onPublisher.call(new Observer<T>() {
@Override
public void onSuccess(T t) {
for (OnObserver<T> observer:onObservers)
observer.onSuccess(t);
}
@Override
public void onError(Throwable throwable) {
for (OnObserver<T> observer:onObservers)
observer.onError(throwable);
}
@Override
public void onFinished() {
for (OnObserver<T> observer:onObservers)
observer.onFinished();
}
});
return this;
}
}
4. 调用
public class Test {
public final static String TAG = "Test";
public void test(){
Publisher.<String>getInstance()
.create(new OnPublisher<String>() {
@Override
public void call(OnObserver<String> observer) {
LogCore.i(TAG, "OnPublisher.call: ");
String res = "1";
if (res != null)
observer.onSuccess(res);
else
observer.onError(new Throwable("error"));
}
})
.bind(new Observer<String>() {
@Override
public void onSuccess(String s) {
LogCore.i(TAG, "Observer.onSuccess: " + s);
}
@Override
public void onError(Throwable throwable) {
}
@Override
public void onFinished() {
LogCore.i(TAG, "Observer.onFinished: " );
}
})
.post();
}
}
与RxJava的不同
- Rxjava是事件订阅的时候就执行触发事件,可以说是订阅一下触发一次;此处设计 为“事件订阅完成之后由post方法统一触发”
- Rxjava其实在事件消费的时机上与传统的观察者模式有所不同。传统观察者模式都是在所有事件订阅完成之后,发出信号而后所有订阅者统一收到同一份事件,而Rxjava则是订阅即触发单独的事件消费
缺陷
- 这个接口的范型其实是有些问题的,不利于后续的map等变换操作,后续是会更改的。不过范型也仅仅只是源码级的约束而已,并不会影响RunTime的结果