设计模式：观察者模式 ——— 城管来了，摊主快跑

今天学习设计模式系列的观察者模式

前言

时间飞逝，转眼初夏已过，尤记得之前读大学的时候，夏季最快乐的时光就是和小伙伴们在球场上打完球后去校门附近的烧烤摊撸串喝酒，那种感受真是大快人心，怎一个爽字了得。不过有时也会遇到特殊状况，在撸串时摊主忽然告知要收摊，连忙向咱们赔礼道歉，缘由是城管将至。咱们无奈只能中断撸串过程，带着没法尽兴的郁闷心情离开.......

好吧，扯远了，说那么多废话也是想介绍两个角色，城管和烧烤摊主，这两个角色其实就至关于观察者模式中的被观察者和观察者，他们的活动过程其实就相似于观察者模式。

观察者模式

开始介绍观察者模式，毫无疑问，先说下它的定义。

定义

定义对象间一种一对多的依赖关系，使得每当一个对象改变状态，则全部依赖于它的对象都会获得通知并被自动更新。

其实就是发布-订阅模式，在实际的项目中很是的常见，好比微信公众号的消息推送就是观察者模式的最直接的应用。

通用类图

上面的类图包含了四个角色，分别是：

• Subject 抽象被观察者：定义被观察者必须实现的职责，它必须可以动态地增长、取消观察者。它通常是抽象类或者是实现类，仅仅完成做为被观察者必须实现的职责：管理观察者并通知观察者。

• Observer 抽象观察者：为全部的具体观察者定义一个接口，在获得主题通知时更新本身。

• ConcreteSubject 具体被观察者：定义被观察者本身的业务逻辑，同时定义对哪些事件进行通知。

• ConcreteObserver 具体观察者：实现抽象观察者角色所须要的更新接口，各个观察者有本身的处理逻辑。

实际例子

讲完了观察者模式的角色后，咱们用实战例子来演示一下，就拿城管和小摊摊主举例好了，城管对应着观察者模式中的被观察者，而摊主就对应着观察者。OK，角色分配好了，咱们开始写代码吧。

抽象被观察者

public abstract class Subject {
    //定义一个观察者数组
    private List<Observer> obs = new ArrayList<>();

    //增长一个观察者
    public void addObserver(Observer o) {
        this.obs.add(o);
    }

    //删除一个观察者
    public void delObserver(Observer o) {
        this.obs.remove(o);
    }

    //通知全部观察者
    public void notifyObservers() {
        for (Observer o : this.obs) {
            o.update();
        }
    }
}
复制代码

具体被观察者

也就是城管，不知道英文怎么拼，用Police代替了，

public class Police extends Subject {
    public void chase(){
        System.out.println("城管：我要来了，还不走");
        // 通知全部观察者
        notifyObservers();
    }
}
复制代码

抽象观察者

public interface Observer {
    /**
     * 通知更新
     * @param message
     */
    void update(String message);
}
复制代码

具体观察者

public class Vendor implements Observer {
    private String name;
    private String message;

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

    @Override
    public void update(String message) {
        System.out.println(name + " 收到： " + message);
    }
}
复制代码

场景类

最后用一个场景类验证一下，

public class Client {

    public static void main(String[] args) {
        // 城管--被观察者
        Police police = new Police();

        // 烧烤摊主--观察者
        Observer barbecueVendor = new Vendor("烧烤摊主");

        // 手抓饼摊主--观察者
        Observer cakeVendor = new Vendor("手抓饼摊主");

        System.out.println("=======增长两个观察者=======");
        police.addObserver(barbecueVendor);
        police.addObserver(cakeVendor);
        police.chase();

        System.out.println("=======删除一个观察者=======");
        police.delObserver(cakeVendor);
        police.chase();
    }
}
复制代码

定义一个城管对象和两个摊主对象，而后执行通知更新的操做，结果以下：

=======增长两个观察者=======
城管：我要来了，还不走
烧烤摊主 收到： 城管要来了，你们跑啊
手抓饼摊主 收到： 城管要来了，你们跑啊
=======删除一个观察者=======
城管：我要来了，还不走
烧烤摊主 收到： 城管要来了，你们跑啊
复制代码

能够看到，咱们的代码能正常增删观察者角色，同时也能通知消息更新，也算是重现了了观察者模式的流转过程。

总结

优势

一、观察者和被观察者之间抽象耦合。不论是增长观察者仍是被观察者都很是容易扩展，并且在Java中都已经实现的抽象层级的定义，在系统扩展方面更是驾轻就熟。

二、对象之间的保持高度的协做。当被观察者发生变化时，全部被观察者都会通知到，而后作出相应的动做。

缺点

一、若是观察者太多，被观察者通知观察者消耗的时间不少，同时开发和调试会比较复杂，影响系统的性能。

二、在Java中消息的通知默认是顺序执行，当某一观察者错误时就会致使系统卡壳，所以通常会采用异步方式。

参考：

《设计模式之禅》