设计模式

简介

观察者模式（Observer Design Pattern）也被称为发布订阅模式（Publish-Subscribe Design Pattern）

在 GoF 的《设计模式》一书中，它的定义是这样的：

Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.

翻译成中文就是：在对象之间定义一个一对多的依赖，当一个对象状态改变的时候，所有依赖的对象都会自动收到通知。
一般情况下，被依赖的对象叫作被观察者（Observable），依赖的对象叫作观察者（Observer）。

在实际的项目开发中，这两种对象的称呼是比较灵活的，有各种不同的叫法，比如：Subject-Observer、Publisher-Subscriber、Producer-Consumer、EventEmitter-EventListener、Dispatcher-Listener。

不管怎么称呼，只要应用场景符合刚刚给出的定义，都可以看作观察者模式。

观察者模式是一个比较抽象的模式，根据不同的应用场景和需求，有完全不同的实现方式

1 回调

//定义一个接口
public interface ICallBack {
    void onClick();
}

触发回调

    //设置callback,使触发回调的类持有该引用
    private void setCallBack(ICallBack iCallBack) {
        mICallBack = iCallBack;
    }

    @Override
    public void onClick(View v) {
        if (mICallBack != null) {
            //触发回调
            mICallBack.onClick();
        }
    }

当被回调时执行操作

        setCallBack(new ICallBack() {
            @Override
            public void onClick() {
                Toast.makeText(CallBackActivity.this, R.string.carried_out, Toast.LENGTH_SHORT).show();
            }
        });

2观察者模式举例

观察者模式描述的是一种一对多的关系「一个被观察者对应多个观察者」，当被观察者的状态发生改变时，所有观察者都会得到通知。

观察者模式又叫做发布-订阅（Publish/Subscribe）模式、模型-视图（Model/View）模式、源-监听器（Source/Listener）模式或从属者（Dependents）模式。

1.png

1.jpeg

操刀

public interface IObsever {
    void receiveContent(String content);
}

public interface IWxServerSubject {
    void attachObsever(IObsever iObserver);
    void detachObsever(IObsever iObserver);
    void notifyObsever();
}

public class KaiWangSubject implements IWxServerSubject {

    private List<IObsever> obsevers = new ArrayList<>();

    private String updateContent = "haha";


    @Override
    public void attachObsever(IObsever iObserver) {
        obsevers.add(iObserver);
    }

    @Override
    public void detachObsever(IObsever iObserver) {
        if (obsevers.contains(iObserver)) {
            obsevers.remove(iObserver);
        }
    }

    @Override
    public void notifyObsever() {
        for (IObsever obsever : obsevers) {
            obsever.receiveContent(updateContent);
        }
    }

    public boolean isAttachObsever(IObsever iObsever) {
        return obsevers.contains(iObsever);
    }

    public void submitContent(String updateContent) {
        this.updateContent = updateContent;
        this.notifyObsever();
    }
}

public class ReaderObsever implements IObsever {
    private String name;

    public ReaderObsever(String name) {
        this.name = name;
    }

    @Override
    public void receiveContent(String content) {
        Log.i("obsever", content);
    }

    public String getName() {
        return name;
    }
}

    private void testObsever() {
        KaiWangSubject kaiWangSubject = new KaiWangSubject();

        ReaderObsever readerObsever1 = new ReaderObsever("1");
        ReaderObsever readerObsever2 = new ReaderObsever("2");
        ReaderObsever readerObsever3 = new ReaderObsever("3");
        ReaderObsever readerObsever4 = new ReaderObsever("4");

        kaiWangSubject.attachObsever(readerObsever1);
        kaiWangSubject.attachObsever(readerObsever2);
        kaiWangSubject.attachObsever(readerObsever3);
        kaiWangSubject.attachObsever(readerObsever4);

        kaiWangSubject.submitContent("kaiWangSubject");
    }

java obsever

public class CoderObsever implements Observer {

    private String name;

    public CoderObsever(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    @Override
    public void update(Observable o, Object arg) {
        Log.i("obsever", name + ":" + arg);
    }
}

public class KaiWangObservable extends Observable {

    public void postContent(String content){
        setChanged();
        notifyObservers(content);
    }
}

    private void testJavaObsever() {
        KaiWangObservable kaiWangObservable = new KaiWangObservable();

        kaiWangObservable.addObserver(new CoderObsever("coder1"));
        kaiWangObservable.addObserver(new CoderObsever("coder2"));
        kaiWangObservable.addObserver(new CoderObsever("coder3"));
        kaiWangObservable.addObserver(new CoderObsever("coder4"));

        kaiWangObservable.postContent("hello world");
    }

基于不同应用场景的不同实现方式

观察者模式的应用场景非常广泛，小到代码层面的解耦，大到架构层面的系统解耦，再或者一些产品的设计思路，都有这种模式的影子，比如，邮件订阅、RSS Feeds，本质上都是观察者模式。

• 有同步阻塞的实现方式，
• 有异步非阻塞的实现方式；
• 有进程内的实现方式，
• 有跨进程的实现方式。

设计模式要干的事情就是解耦。创建型模式是将创建和使用代码解耦，结构型模式是将不同功能代码解耦，行为型模式是将不同的行为代码解耦，具体到观察者模式，它是将观察者和被观察者代码解耦

参考

人人都会设计模式---观察者模式--Observer
56 | 观察者模式（上）：详解各种应用场景下观察者模式的不同实现方式