一个接口形式的观察者模式

一个接口形式的观察者模式

总觉得外面世界有多美好，用几滴眼泪才换来骄傲

​ ——林中鸟

现在面试应该或多或少的都会提及观察者模式，如果你还没有被提到，那么别急你一定听说过火的都快要被烧焦的RxJava，那么今天又到了出橙色or白色装备的时间了。

看下接口形式的观察者怎么实现，上例子。

public class Observerable {

//    持有一个接口
    private OnObservListener onObservListener;

    public Observerable(OnObservListener onObservListener) {
        this.onObservListener = onObservListener;
    }

//    静态创建方法
    public static Observerable CREATE(OnObservListener onObserListener){
        return new Observerable(onObserListener);
    }

//    绑定观察者
    public void addObServer(ObServer obServer){
        addObServer(obServer,this);
    }
    public void addObServer(ObServer obServer,Observerable observerable){
        if (obServer == null){
            throw new IllegalArgumentException("obServer == null");
        }
        if (observerable.onObservListener == null){
            throw new IllegalStateException("onObservListener == null");
        }
      // 创建代理模式来包裹实现
        obServer = new ProxyObServer(obServer);
        observerable.onObservListener.call(obServer);
    }
}

观察者监听接口：

public interface OnObservListener {

   /**
      * @param obServer 观察者
    */
    void call(ObServer obServer);
}

public interface ObServer {

    void onStart();
    void onNext(String s);
    void onFinish();
}

代理模式的实现：

public class ProxyObServer implements ObServer {

    private ObServer obServer;

    public ProxyObServer(ObServer obServer) {
        this.obServer = obServer;
    }

    @Override
    public void onStart() {
        obServer.onStart();
    }

    @Override
    public void onNext(String s) {
        obServer.onNext(s);
    }

    @Override
    public void onFinish() {
        obServer.onFinish();
    }
}

测试代码：

public class Main {

    public static void main(String[] args) {
        Observerable observerable = Observerable.CREATE(new OnObservListener() {
            @Override
            public void call(ObServer obServer) {
//                obServer.onStart();
                obServer.onNext("is on next");
                obServer.onFinish();
            }
        });
        ObServer obServer = new ObServer() {
            @Override
            public void onStart() {
                System.out.println("onStart");
            }

            @Override
            public void onNext(String s) {
                System.out.println("onNext:"+s);
            }

            @Override
            public void onFinish() {
                System.out.println("onFinish");
            }
        };
        observerable.addObServer(obServer);
    }
}

输出信息：

onNext:is on next
onFinish

等一下，看到这段测试代码我记得大约在冬季啊，顿时思绪万千

你是否见过这个栗子：

//被观察者
Observable observable = Observable.create(new Observable.OnSubscribe<String>() {
    @Override
    public void call(Subscriber<? super String> subscriber) {
        subscriber.onNext("Hello");
        subscriber.onCompleted();
    }
});

//实现observer的抽象类
Subscriber<String> subscriber = new Subscriber<String>() {
    @Override
    public void onNext(String s) {
        Log.d(tag, "Item: " + s);
    }

    @Override
    public void onCompleted() {
        Log.d(tag, "Completed!");
    }

    @Override
    public void onError(Throwable e) {
        Log.d(tag, "Error!");
    }
};

observable.subscribe(subscriber);

PS 上方这段代码出自:给 Android 开发者的 RxJava 详解

多么惊人的相似啊？

那我是不是改一改再加上个泛型就可以向RxJava-1.x看齐?

Too young, Too simple.

我发出这样的感慨：我目前写的这段代码，都未曾显示RxJava的万分之一，我只能通过这样的方式，去学习他们的代码理念，我渴望力量啊。
Demo链接