（4.6.22.1）来吧，是时候撸一份自己的RxJava框架啦：观察者模式实现链式调用

（4.6.22）来吧，是时候撸一份自己的RxJava框架啦
链式调用实现原理： 观察者模式
1.1 控制器 持有 1个生产者 和 多个消费者
1.2 调用生产者的生产函数，并将多个消费者实例注入其中

设计思路

• 核心控制器

  • 实现 注册事件生产者，并持有生产者实例
  • 实现 添加事件的消费者，并持有消费者容器的实例
  • 实现 开启整个事件流程，即调用生产者的事件函数，并将消费者们注入其中

• 生产者接口

  • void call（消费者们）{}
    函数持有消费者实例，在适当时机，调用消费者实例的对应成员函数

• 消费者接口

  • onSuccess(T t);
    t为生产者在call函数中注入的数据实例
  • onError(Throwable throwable)
    throwable为生产者在call函数中注入的数据实例

实践

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则是订阅即触发单独的事件消费

缺陷

1. 这个接口的范型其实是有些问题的，不利于后续的map等变换操作，后续是会更改的。不过范型也仅仅只是源码级的约束而已，并不会影响RunTime的结果