继续整理记录这段时间来的收获，详细代码可在我的Gitee仓库SpringBoot克隆下载学习使用！

6.7 观察者模式

6.7.1 定义

• 又称发布-订阅模式，定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象
• 主体对象在状态变化时，会通知所有的观察者对象，使其自动更新

6.7.2 结构

• 抽象主题(被观察者)：将所有观察者对象保存在一个集合里，每个主题都可以有任意数量的观察者，提供一个接口来增加和删除观察者对象
• 具体主题(具体被观察者)：将有关状态存入具体观察者对象，在具体主题内部状态发生改变时，给所有注册过得观察者发送通知
• 抽象观察者：观察者的抽象类，定义了一个更新接口，使得在得到主题更改时通知更新自己
• 具体观察者：实现抽象观察者定义的更新接口，以便得到主题更改时更新自身状态

6.7.3 案例(微信公众号)

• 抽象观察者

public interface Observer {  
//    自动更新方法  
    void update(String model);  
}

• 抽象主题

public interface Subject {  
    //    删除观察者  
    void deleteSubject(Observer observer);  
    //    添加观察者  
    void addSubject(Observer observer);  
//    通知观察者对象  
    void notify(String message);  
}

• 具体主题

public class Subscription implements Subject{  
//    集合，用来存储观测察者对象  
    List<Observer> observerList = new ArrayList<Observer>();  
    @Override  
    public void deleteSubject(Observer observer) {  
        observerList.remove(observer);  
    }  
    @Override  
    public void addSubject(Observer observer) {  
        observerList.add(observer);  
    }  
    @Override  
    public void notify(String message) {  
//        遍历通知集合中的对象  
        for (Observer observer : observerList) {  
            observer.update(message);  
        }  
    }  
}

• 具体观察者

public class WeChatObserver implements Observer{  
    String name;  
    public WeChatObserver(String name) {  
        this.name = name;  
    }  
    @Override  
    public void update(String message) {  
        System.out.println(name +"-" + message);  
    }  
}

• 测试

    public static void main(String[] args) {  
//        创建公众号对象  
        Subscription subscription = new Subscription();  
//        创建订阅者  
        WeChatObserver weChatObserver = new WeChatObserver("张三");  
        WeChatObserver weChatObserver1 = new WeChatObserver("李四");  
        WeChatObserver weChatObserver2 = new WeChatObserver("王五");  
        subscription.addSubject(weChatObserver);  
        subscription.addSubject(weChatObserver1);  
        subscription.addSubject(weChatObserver2);  
        subscription.notify("更新");  
    }

• 结果
  - 类图

6.7.4 优缺点

6.7.4.1 优点

• 降低了目标与观察者之间耦合关系，是抽象耦合
• 被观察者发送通知，所有注册的观察者都收到信息(广播机制)

6.7.4.2 缺点

• 若观察者多，则所有观察者收到被观察者发送的通知会耗时
• 若观察者有循环依赖，则所有观察者发送通知会使观察者循环调用，导致系统崩溃

6.7.5 使用场景

• 对象间存在一对多关系，一个对象的状态发生改变会影响其他对象
• 当抽象模型有两方面，其中一个方面依赖另一个方面

6.7.6 JDK源码

Java中，通过java.util.Observerable类和java.util.Observer定义观察者模式，实现子类就可编写观察者实例

6.7.6.1 Observable类

• 抽象目标类(被观察者),有vector集合成员变量，用于保存所有要通知的观察者对象，重要方法如下:
• void addObserver(Observer o):将新观察者对象添加到集合中
• void notifyObservers(Object o):调用集合中所有观察者对象的update方法，越晚加入的观察者越先被通知
• void setChange():设置内部状态boolean类型标志，表明目标对象发生变化了，true时notifyObservers（）方法执行

6.7.6.2 Observer接口

• 抽象观察者，监视目标对象，档期发生变化时观察中得到通知，并调用update（）方法

6.7.6.3 案例（警察抓小偷）

• 具体主题

public class Thief extends Observable {  
    String name;  
    public Thief(String name) {  
        this.name = name;  
    }  
    public void steal(){  
        System.out.println("小偷" + name + ":不好，偷东西被发现啦");  
        super.setChanged();  
        super.notifyObservers();  
    }  
    public String getName() {  
        return name;  
    }  
}

• 具体观察者

public class Policeman implements Observer {  
    @Override  
    public void update(Observable o, Object arg) {  
        System.out.println("警察：" +((Thief) o).getName() + "你已经被包围了，投降不投降？");  
    }  
}

• 测试

public static void main(String[] args) {  
    Thief thief = new Thief("王五");  
    Policeman policeman1 = new Policeman();  
    Policeman policeman2 = new Policeman();  
    thief.addObserver(policeman1);  
    thief.addObserver(policeman2);  
    thief.steal();  
}

• 结果