设计模式之观察者模式

观察者模式，顾名思意就是观察与被观察的关系，比如你在烧开水得时时看着它开没开，你就是观察者，开水就是被观察者;比如商品缺货，你会看商品是否来货，你就是观察者，商品就是被观察者。

观察者又叫做发布订阅（Publish/Subscribe）模式。
观察者模式定义一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象，这个主题对象在状态发生变化时，会通知所有观察者对象，使他们能够自动更新自己。

观察模式结构图

Subject类

它把所有对观察者对象的引用保存在一个集合里，每个主题都可以有任何数量的观察者，抽象主题提供一个接口，可以增加和删除观察者对象。

Observer类

抽象观察者，为所有的具体观察者定义一个接口，在得到主题的通知更新自己。

ConcreteSubject类

具体主题将所有关状态存入具体观察者对象，在将有关状态存入具体观察者对象，在具体主题的内部状态改变是，给所有等级过的观察者发出通知。

ConcreObserver类

具体观察者，实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态相协调。

 

观察者模式典型代码

Subject类（抽象通知者）

public abstract class Subject {
    // 定义一个观察者集合用于存储所有观察者对象  
    protected List<Observer> list = new ArrayList<Observer>();

    // 增加观察者
    public void attach (Observer observer) {
        list.add(observer);
    }
    // 移除观察者
    public void detach (Observer observer) {
        list.remove(observer);
    }
    // 通知者
    public void Notify ();
    

}

Observer 类（抽象观察者）

public abstract class Observer {

    public abstract void update();
}

ConcreteSubject类（具体通知者）

public class ConcreteSubject extends  Subject {

    private String subjectState;

    public String getSubjectState() {
        return subjectState;
    }

    public void setSubjectState(String subjectState) {
        this.subjectState = subjectState;
    }

    @Override
    public void Notify() {
        for (Observer observer: list) {
                observer.update();
        }
    }

}

ConcreteObserver类（具体观察者）

public class ConcreteObserver extends Observer {

   private String name;

   private String observerState;

    private ConcreteSubject concreteSubject;

    public ConcreteObserver(ConcreteSubject concreteSubject,String name) {
        this.concreteSubject = concreteSubject;
        this.name = name;
    }

    @Override
    public void update() {
           observerState = concreteSubject.getSubjectState();
           System.out.println("name :"+name);
           System.out.println("observerState :"+observerState);
    }

    public ConcreteSubject getConcreteSubject() {
        return concreteSubject;
    }

    public void setConcreteSubject(ConcreteSubject concreteSubject) {
        this.concreteSubject = concreteSubject;
    }
}

测试方法

  public static void main(String[] args) {
        ConcreteSubject s = new ConcreteSubject();
        s.attach(new ConcreteObserver(s,"X"));
        s.attach(new ConcreteObserver(s,"Y"));
        s.attach(new ConcreteObserver(s,"Z"));
        s.setSubjectState("ABC");
        s.Notify();

  }

测试结果

name :X
observerState :ABC
name :Y
observerState :ABC
name :Z
observerState :ABC

 

实际应用

软件公司欲开发一款多人联机对战游戏（类似魔兽世界、星际争霸等游戏），在该游戏中，多个玩家可以加入同一战队组成联盟，当战队中某一成员受到敌人攻击时将给所有其他盟友发送通知，盟友收到通知后将作出响应。

抽象观察类 

interface Observer {
    public String getName();
    public void setName(String name);
    public void help(); //声明支援盟友方法
    public void beAttacked(AllyControlCenter acc); //声明遭受攻击方法
}

 战队成员类：具体观察者类

class Player implements Observer {
    private String name;

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

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }

    //支援盟友方法的实现
    public void help() {
        System.out.println("坚持住，" + this.name + "来救你！");
    }

    //遭受攻击方法的实现，当遭受攻击时将调用战队控制中心类的通知方法notifyObserver()来通知盟友
    public void beAttacked(AllyControlCenter acc) {
        System.out.println(this.name + "被攻击！");
        acc.notifyObserver(name);       
    }
}

战队控制中心类：目标类

abstract class AllyControlCenter {
    protected String allyName; //战队名称
    protected ArrayList<Observer> players = new ArrayList<Observer>(); //定义一个集合用于存储战队成员

    public void setAllyName(String allyName) {
        this.allyName = allyName;
    }

    public String getAllyName() {
        return this.allyName;
    }

    //注册方法
    public void join(Observer obs) {
        System.out.println(obs.getName() + "加入" + this.allyName + "战队！");
        players.add(obs);
    }

    //注销方法
    public void quit(Observer obs) {
        System.out.println(obs.getName() + "退出" + this.allyName + "战队！");
        players.remove(obs);
    }

    //声明抽象通知方法
    public abstract void notifyObserver(String name);
}

 具体战队控制中心类：具体目标类

class ConcreteAllyControlCenter extends AllyControlCenter {
    public ConcreteAllyControlCenter(String allyName) {
        System.out.println(allyName + "战队组建成功！");
        System.out.println("----------------------------");
        this.allyName = allyName;
    }

    //实现通知方法
    public void notifyObserver(String name) {
        System.out.println(this.allyName + "战队紧急通知，盟友" + name + "遭受敌人攻击！");
        //遍历观察者集合，调用每一个盟友（自己除外）的支援方法
        for(Object obs : players) {
            if (!((Observer)obs).getName().equalsIgnoreCase(name)) {
                ((Observer)obs).help();
            }
        }       
    }
}

测试类

class Client {  
    public static void main(String args[]) {  
        //定义观察目标对象  
AllyControlCenter acc;  
        acc = new ConcreteAllyControlCenter("金庸群侠");  

        //定义四个观察者对象  
        Observer player1,player2,player3,player4;  

        player1 = new Player("杨过");  
        acc.join(player1);  

        player2 = new Player("令狐冲");  
        acc.join(player2);  

        player3 = new Player("张无忌");  
        acc.join(player3);  

        player4 = new Player("段誉");  
        acc.join(player4);  

        //某成员遭受攻击  
        player1.beAttacked(acc);  
    }  
}

 测试结果

金庸群侠战队组建成功！
----------------------------
杨过加入金庸群侠战队！
令狐冲加入金庸群侠战队！
张无忌加入金庸群侠战队！
段誉加入金庸群侠战队！
杨过被攻击！
金庸群侠战队紧急通知，盟友杨过遭受敌人攻击！
坚持住，令狐冲来救你！
坚持住，张无忌来救你！
坚持住，段誉来救你！

适用场景

1、当一个对象需要同时改变其他对象的时候，而且它不知道具体有多少个对象有待改变时，应考虑使用观察者模式。

2、当一个模型有2个方面，其中一个方面依赖于另一个方面，这时使用观察者模式可以将这两者封装在独立的对象中使它们各自可以独立的改变和使用。

应用场景

观察者模式还可以用于网络中的客户端和服务器，比如手机中的各种App的消息推送，服务端是观察者，各个手机App是被观察者，一旦服务器上的数据(如App升级信息)有更新，就会被推送到手机客户端。

观察模式与MVC

在当前流行的MVC(Model-View-Controller)架构中也应用了观察者模式，MVC是一种架构模式，它包含三个角色：模型(Model)，视图(View)和控制器(Controller)。其中模型可对应于观察者模式中的观察目标，而视图对应于观察者，控制器可充当两者之间的中介者。当模型层的数据发生改变时，视图层将自动改变其显示内容。

 

模型层提供的数据是视图层所观察的对象，在视图层中包含两个用于显示数据的图表对象，一个是柱状图，一个是饼状图，相同的数据拥有不同的图表显示方式，如果模型层的数据发生改变，两个图表对象将随之发生变化，这意味着图表对象依赖模型层提供的数据对象，因此数据对象的任何状态改变都应立即通知它们。同时，这两个图表之间相互独立，不存在任何联系，而且图表对象的个数没有任何限制，用户可以根据需要再增加新的图表对象，如折线图。在增加新的图表对象时，无须修改原有类库，满足“开闭原则”。

观察模式的优点

1）观察者模式可以实现表示层和数据逻辑层的分离，定义了稳定的消息更新传递机制，并抽象了更新接口，使得可以有各种各样不同的表示层充当具体观察者角色。 
2) 观察者模式在观察目标和观察者之间建立一个抽象的耦合。观察目标只需要维持一个抽象观察者的集合，无须了解其具体观察者。由于观察目标和观察者没有紧密地耦合在一起，因此它们可以属于不同的抽象化层次。 
3) 观察者模式支持广播通信，观察目标会向所有已注册的观察者对象发送通知，简化了一对多系统设计的难度。 
4) 观察者模式满足“开闭原则”的要求，增加新的具体观察者无须修改原有系统代码，在具体观察者与观察目标之间不存在关联关系的情况下，增加新的观察目标也很方便。

观察模式的缺点

1) 如果一个观察目标对象有很多直接和间接观察者，将所有的观察者都通知到会花费很多时间。 
2) 如果在观察者和观察目标之间存在循环依赖，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。 
3) 观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。

总结

观察者模式所做的工作其实就是在解耦，让解耦的双方依赖依赖于抽象，而不是依赖于具体，从而使各自的变化都不会影响另一边的变化。凡事涉及到一对一或者一对多的对象交互的场景都可以使用观察者模式。