设计模式-观察者模式

什么是观察者模式

观察者模式是一种一对多的依赖,多个观察者同时监听同一个对象,当对象发生状态改变的时候，会通知它的观察者们

举例

军营中有 将军 ,将军管着 步兵，骑兵，弓箭手等， 将军的指令会通知到军队中，那么，这样一来,步兵，骑兵，弓箭手就相当于 将军这个对象的观察者了,将军的命令下发后，收到命令的军队会做出相应的反应

代码

public class TestObserver {

    public static void main(String[] args) {

        ObserverGeneral observerGeneral = new ObserverGeneral();

        System.out.println("骑兵,步兵,弓箭手 待命  !!! ");

        MyObserver cavalryOs = new CavalryOs();
        MyObserver footMan = new FootMan();
        MyObserver archer = new Archer();


        String task1 = "全体命令 -> 今晚三更 进攻敌营 !!";
        observerGeneral.addObserver(cavalryOs);
        observerGeneral.addObserver(footMan);
        observerGeneral.addObserver(archer);
        observerGeneral.notify(task1);

        String task2 = "骑兵命令 -> 今晚二更 先去突袭 !!";

        //将步兵和弓箭手从通知者中移除
        observerGeneral.delObserver(footMan);
        observerGeneral.delObserver(archer);
        observerGeneral.notify(task2);

    }
}

/**
 * 将军
 */
class ObserverGeneral{


    List<MyObserver> observerList = new ArrayList<>();

    /**
     * 添加一个观察者
     * @param observer
     */
    public void addObserver( MyObserver observer){
        observerList.add(observer);
    }

    /**
     * 删除一个观察者
     * @param observer
     */
    public void delObserver( MyObserver observer ){
        observerList.remove(observer);
    }


    /**
     * 通知观察者
     * @param o
     */
    public void notify( Object o ){
        System.out.println("将军发布命令 : " + o.toString());
        for (MyObserver observer :observerList ){
            observer.update(o);
        }
    }

}

interface MyObserver{
    void update( Object o);
}


/**
 * 骑兵
 */
class CavalryOs implements  MyObserver{

    @Override
    public void update(Object o) {
        System.out.println("骑兵接受到了通知 : " + o.toString());
    }
}

/**
 * 步兵
 */
class FootMan implements  MyObserver{

    @Override
    public void update(Object o) {
        System.out.println("步兵接受到了通知 : " + o.toString());
    }
}

/**
 * 弓箭手
 */
class Archer implements  MyObserver{

    @Override
    public void update(Object o) {
        System.out.println("弓箭手接受到了通知 : " + o.toString());
    }
}

执行结果:

骑兵,步兵,弓箭手 待命 !!!
将军发布命令 : 全体命令 -> 今晚三更 进攻敌营 !!
骑兵接受到了通知 : 全体命令 -> 今晚三更 进攻敌营 !!
步兵接受到了通知 : 全体命令 -> 今晚三更 进攻敌营 !!
弓箭手接受到了通知 : 全体命令 -> 今晚三更 进攻敌营 !!
将军发布命令 : 骑兵命令 -> 今晚二更 先去突袭 !!
骑兵接受到了通知 : 骑兵命令 -> 今晚二更 先去突袭 !!

在jdk中的体现

这里Observer 就是一个观察者,update 的参数 arg 表示发布的通知,o 就是 发布者


Obserable 内部是用vertor存储的 Observer

在Spring 源码中的体现

每个 ApplicationListener 相当于一个观察者

ApplicationEventMulticaster 相当于发布者 ,拥有删除观察者 ,添加观察者,和发布通知的功能