（4.6.22.3）来吧，是时候撸一份自己的RxJava框架啦：装饰器模式实现操作符顺序调用

操作符的原理： 适配器模式(装饰器模式)
3.1 数据结构链式结构的头插法，实现装饰器模式
3.2 头部调用

设计思路

装饰器模式，实现onObserver代理的通用集成，并持有上一个装换

图形实例

Publisher
.create()
.h1 // 创建observer类型的h1， header 和 last指针都指向该节点，h1.pre为null
.h2 // 创建observer类型的h2，h2.pre为null。设置h1.pre = h2， 同时 last后移
.h3// 创建observer类型的h3，h3.pre为null。设置h2.pre = h3， 同时 last后移
.bind(observerA)
.post();// 设置h3.pre = observerA， 并将header 传递给 生产者.call(header)方法中

此时，我们在call中调用 header.onSuccess(T)时，其实是 ：

• 先调用Pre=h1.Success{1. 完成h1的func1 2. 调用h1.Pre=h2.Success
  
  • {1. 完成h2的func1 2. 调用h2.Pre=h3.Success
    
    • {1. 完成h3的func1 2. 调用h3.Pre=onObserver.Success}}}

实践

1. 链式结构

1.1 抽象节点

/** * 【观察者---消费者： 事件的消费者】 的控制器代理： 变换类通用代理 * 实现链式调用的数据结构 * Created by yhf on 16/12/18. */public abstract class Change<I,O> implements OnObserver<I>,IObserverProxy<O> {    protected OnObserver<O> preChange; // 上个变换实例---指向上一个指针    protected Func1 changeImpl; // 转换代理 实例    protected IObserverProxy iObserverProxy;// 被代理的观察者们的 【实际】控制器代理    public Change(OnObserver<I> preChange) {        this.preChange = (OnObserver<O>) preChange;        iObserverProxy = (IObserverProxy<I>) preChange;    }    public Change() {    }    /**     * 调用 【实际 【观察者---消费者： 事件的消费者】】控制器 代理   向观察者容器中，增删查     *     */    @Override    public void addObserver(OnObserver observer) {        iObserverProxy.addObserver(observer);    }    @Override    public void rmObserver(OnObserver observer) {        iObserverProxy.addObserver(observer);    }    @Override    public void clear() {        iObserverProxy.clear();    }    @Override    public Vector<OnObserver<O>> getObservers() {        return iObserverProxy.getObservers();    }    /**     * //调用 preChange 代理     */    @Override    public void onError(Throwable throwable) {        preChange.onError(throwable);    }    @Override    public void onFinished() {        preChange.onFinished();    }    /**     * 完成链式结构     * @param preChange     */    public void setPreChange(OnObserver<I> preChange){        this.preChange = (OnObserver<O>) preChange;        iObserverProxy = (IObserverProxy<I>) preChange;    }    public void setChangeImpl(Func1 changeImpl) {        this.changeImpl = changeImpl;    }}

1.1.1 过滤操作的 链表节点

我们可以看到，它是先调用 自身的 过滤实例函数，如果成功了，才会调用前一个的

/** * 【观察者---消费者： 事件的消费者】 的控制器代理： 过滤类同用代理 * 链式的数据结构的具体节点 * Created by yhf on 16/12/18. */public class FilterChange<T> extends Change<T,T>{    /**     * //唯一  没有直接使用  实际代理控制器的地方     // !!! 根据preChange代理mapProxy.call(t)的返回值，作为参数，调用onSucces     * @param t     */    @Override    public void onSuccess(T t) {        if ((Boolean) changeImpl.call(t))            preChange.onSuccess(t);    }}

1.1.2 map 数据转换操作的 链表节点

/** * 【观察者---消费者： 事件的消费者】 的控制器代理： 变换类同用代理 * 链式的数据结构的具体节点 * Created by yhf on 16/12/18. */public class MapChange<I,O> extends Change<I,O>{    /**     * //唯一  没有直接使用  实际代理控制器的地方     // !!! 根据preChange代理mapProxy.call(t)的返回值，作为参数，调用onSucces     * @param i     */    @Override    public void onSuccess(I i) {        preChange.onSuccess((O) changeImpl.call(i));    }}

2. 图形实例的实现过程

    private Change changeHead;    private Change changeLast;        private Publisher() {        ...        changeHead = new Change() {            @Override            public void onSuccess(Object o) {                preChange.onSuccess(o);            }        };        changeLast = changeHead;        ...    }    /**     * 实现链式的顺序调用方式,就是图示的h1.2.3操作     * 每个变换代理中持有上个变换代理实例，调用上个变换代理的变换函数     *   h1------pre----> h2------pre----->h3     *  head                              Last     *  其实就是 数据结构的链式结构，尾插法     * @param change  变换的实例对象     * @param changeProxy 变换的通用代理     * @param <I>     * @param <O>     * @return     */    @Override    public <I, O> IPublisher<T> change(Func1<I, O> change, Change changeProxy) {        changeProxy.setChangeImpl(change);// 设置节点的自身操作函数        changeLast.setPreChange(changeProxy); // 设置节点前驱        changeLast = changeProxy; // last指针后移        return this;    }    @Override    public Future post() {        /**             *  h1------pre----> h2------pre----->h3---->onObserver             *  head                              Last             *  其实就是 数据结构的链式结构，尾插法             */            changeLast.setPreChange(onObserver);        /**         *  h1------pre----> h2------pre----->h3---->onObserver         *  head                              Last         *  调用changeHead.onSuccess的过程就是：         *  先调用Pre=h1.Success{1. 完成h1的func1 2. 调用h1.Pre=h2.Success         *                                                        {1. 完成h2的func1 2. 调用h2.Pre=h3.Success         *                                                                                              {1. 完成h3的func1 2. 调用h3.Pre=onObserver.Success}}}         */        onPublisher.call(changeHead); // 注入 消费者们的代理类        OnPublisherProxy proxy = (OnPublisherProxy) onPublisher;        return proxy.getFuture();    }