漫画设计模式：每周一篇设计模式之观察者模式

以下图，产品经理接到老板通知，须要临时新增需求，万能的产品经理，马上通知全部程序员去实现该需求。

小安用程序的形式实现上图的过程，代码以下：

/**
 * @Author: 欢迎关注公众号：程序员小安
 * @description: 老板
 * @CreateDate: 2019/10/30
 * @Version: 1.0
 */
public class Boss {
    public void sendOrder(){
        ProductManager productManager = new ProductManager();
        productManager.demandChanged();
    }
}
复制代码

/**
 * @Author: 欢迎关注公众号：程序员小安
 * @description: 产品经理
 * @CreateDate: 2019/10/30
 * @Version: 1.0
 */
public class ProductManager {
    public void demandChanged(){
        Programmer programmer1 = new Programmer();
        Programmer programmer2 = new Programmer();
        Programmer programmer3 = new Programmer();
        programmer1.updateCode();
        programmer2.updateCode();
        programmer3.updateCode();
    }
}
复制代码

/**
 * @Author: 欢迎关注公众号：程序员小安
 * @description: 程序员
 * @CreateDate: 2019/10/30
 * @Version: 1.0
 */
public class Programmer {
    public void updateCode(){
        //苦逼的完成需求
    }
}
复制代码

观察者模式：

定义了对象之间的一对多依赖，这样一来，当一个对象改变状态时，它的全部依赖着都会受到通知并自动更新。

官方定义不太好理解，我翻译一下，在观察者模式中，对象之间有一对多的依赖关系，好比一个产品经理对多个程序员，当产品经理有需求变动时，他的全部依赖的程序员都会收到需求变动通知，并修改本身的程序完成该需求。

采用观察者模式的UML图：

继承Subject的类:就是观察者模式中的“被观察者”，它会把全部观察者保存在一个集合中。 实现Observer的类：就是观察者模式中的“观察者”，它会把本身注册进被观察者中的集合中，从而使被观察者发生改变时，通知本身；也能够把本身从被观察者集合中删除，从而不接受观察者发来的通知。

被观察者父类：

/**
 * @Author: 欢迎关注公众号：程序员小安
 * @description: 抽象者父类
 * @CreateDate: 2019/10/30
 * @Version: 1.0
 */
public class Subject {
    //观察者对象列表
    private List<Observer> observers = new ArrayList<Observer>();

    /**
     * 注册观察者对象
     * @param observer
     */
    public void registerObserver(Observer observer){
        if(!observers.contains(observer)) {
            observers.add(observer);
        }
    }

    /**
     * 解绑观察者对象
     */
    public void unRegisterObserver(Observer observer){
        if(!observers.contains(observer)) {
            observers.remove(observer);
        }
    }

    //通知全部注册的观察者执行对应操做
    public  void notifyObservers(){
        for (Observer observer : observers) {
            observer.updateCode();
        }
    }
}
复制代码

具体的被观察者：

/**
 * @Author: 欢迎关注公众号：程序员小安
 * @description: 具体的被观察者（产品经理）
 * @CreateDate: 2019/10/30
 * @Version: 1.0
 */
public class ProductManager  extends Subject{

    private static class ProductManagerSingletonHolder {
        private static final ProductManager INSTANCE = new ProductManager();
    }
    private ProductManager (){}
    public static final ProductManager getInstance() {
        return ProductManagerSingletonHolder.INSTANCE;
    }

    //需求变动，通知观察者
    public void demandChanged(){
        notifyObservers();
    }
}
复制代码

观察者公共接口：

/**
 * @Author: 欢迎关注公众号：程序员小安
 * @description: 抽象的观察者，全部的观察者都实现该接口
 * 当被观察者有变化须要通知时，有了一个共同的接口。
 * @CreateDate: 2019/10/30
 * @Version: 1.0
 */
public interface Observer {
     void updateCode();
}
复制代码

具体观察者对象：

/**
 * @Author: 欢迎关注公众号：程序员小安
 * @description: 观察者（程序员1）
 * @CreateDate: 2019/10/30
 * @Version: 1.0
 */
public class Programmer1 implements Observer{
    public Programmer1() {
        ProductManager.getInstance().registerObserver(this);
    }

    @Override
    public void updateCode() {
        //苦逼的完成需求
    }
}
复制代码

/**
 * @Author: 欢迎关注公众号：程序员小安
 * @description: 观察者（程序员2）
 * @CreateDate: 2019/10/30
 * @Version: 1.0
 */
public class Programmer2 implements Observer{
    public Programmer2() {
        ProductManager.getInstance().registerObserver(this);
    }

    @Override
    public void updateCode() {
        //苦逼的完成需求
    }
}
复制代码

/**
 * @Author: 欢迎关注公众号：程序员小安
 * @description: 观察者（程序员3）
 * @CreateDate: 2019/10/30
 * @Version: 1.0
 */
public class Programmer3 implements Observer{
    public Programmer3() {
        ProductManager.getInstance().registerObserver(this);
    }

    @Override
    public void updateCode() {
        //苦逼的完成需求
    }
}
复制代码

触发条件：

/**
 * @Author: 欢迎关注公众号：程序员小安
 * @description: 触发条件：老板
 * @CreateDate: 2019/10/30
 * @Version: 1.0
 */
public class Boss {
    public void sendOrder(){
        ProductManager.getInstance().demandChanged();
    }
}
复制代码

采用观察者模式后，观察者跟被观察者之间彻底松耦合，当须要新增一个新的观察者时，由于被观察者惟一依赖的是一个实现Observer接口的列表，因此咱们能够不修改原有被观察者的代码，随时增长观察者。同理，也能够随时删除某个观察者。 另外一方面，主要注册的观察者，必定会收到通知，不存在通知遗漏的状况。

观察者模式的优势：

（1）具体被观察者和具体观察者是松耦合关系。

（2）观察者模式知足“开-闭原则”。

观察者模式的缺点：

（1）若是一个被观察者对象有不少的直接和间接的观察者的话，将全部的观察者都通知到会花费不少时间。

（2）若是在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能致使系统崩溃。

（3）观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。

观察者模式的应用场景：

（1） 对一个对象状态的更新，须要其余对象同步更新，并且其余对象的数量动态可变。

（2）对象仅须要将本身的更新通知给其余对象而不须要知道其余对象的细节。

---

若有错误欢迎指出来，一块儿学习。