Java 设计模式（八）观察者模式

一、定义

观察者模式定义了一个一对多的依赖关系，让多个观察者对象同时监听同一个主题对象。当这个主题状态发生改变时，会通知所有观察者对象，让它们自动更新自己。

二、类似场景

聊天室程序的创建。服务器创建好后，A、B、C三个客户端连接好公开聊天。A向服务器发送数据，服务器在将数据分别发送给其他在线客户。也就是说，每个客户端需要更新服务器端的数据。
网站上，很多人订阅了“Java主题”的新闻。当有这个主题新闻时，就会将这些新闻发给所有订阅的人。
大家在玩CS游戏时，服务器需要将每个人的方位变化发给所有的客户。

　　上面这些场景，我们都可以使用观察者模式来处理。我们可以把多个订阅者、客户称之为观察者；需要同步给多个订阅者的数据封装到对对象中，称之为目标。

三、模式结构

抽象主题角色(Subject): 把所有对观察者对象的引用保存在一个集合中，每个抽象主题角色都可以有任意数量的观察者。抽象主题提供一个接口，可以增加和删除观察者角色。一般用一个抽象类和接口来实现。
具体主题角色(ConcreteSubject): 在具体主题内部状态改变时，给所有登记过的观察者发出通知。具体主题角色通常用一个子类实现。
抽象观察者角色(Observer)：为所有具体的观察者定义一个接口，在得到主题的通知时更新自己。
具体观察者角色(ConcreteObserver)：该角色实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态相协调。通常用一个子类实现。如果需要，具体观察者角色可以保存一个指向具体主题角色的引用。

类图：

这里写图片描述

代码示例：

import java.util.*;

//抽象观察类
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);
    }
}

编译并运行程序，输出结果如下：

金庸群侠战队组建成功！

—————————-

杨过加入金庸群侠战队！

令狐冲加入金庸群侠战队！

张无忌加入金庸群侠战队！

段誉加入金庸群侠战队！

杨过被攻击！

金庸群侠战队紧急通知，盟友杨过遭受敌人攻击！

坚持住，令狐冲来救你！

坚持住，张无忌来救你！

坚持住，段誉来救你！

在本实例中，实现了两次对象之间的联动，当一个游戏玩家Player对象的beAttacked()方法被调用时，将调用AllyControlCenter的notifyObserver()方法来进行处理，而在notifyObserver()方法中又将调用其他Player对象的help()方法。Player的beAttacked()方法、AllyControlCenter的notifyObserver()方法以及Player的help()方法构成了一个联动触发链，执行顺序如下所示：

Player.beAttacked() –> AllyControlCenter.notifyObserver() –>Player.help()

四、推模式与拉模式

推模式：每次都会把通知以广播的方式发送给所有观察者，所有观察者只能被动接收，推送的信息通常是主题对象的全部或部分数据。
拉模式：主题对象在通知观察者的时候，只传递少量信息。如果观察者需要更具体的信息，由观察者主动到主题对象中获取，相当于是观察者从主题对象中拉数据。一般这种模型的实现中，会把主题对象自身通过update()方法传递给观察者，这样在观察者需要获取数据的时候，就可以通过这个引用来获取了。
比较：推模式是假定主题对象知道观察者需要的数据；而拉模式是主题对象不知道观察者具体需要什么数据，没有办法的情况下，干脆把自身传递给观察者，让观察者自己去按需要取值。

五、Java自带对观察者模式的支持

JavaSE中提供了java.util.Observable和java.util.Observer来实现观察者模式。

代码示例：
具体目标对象：

public class ConcreteSubject extends Observable{
    private int state;

    public int getState() {
        return state;
    }
    public void setState(int state) {
        this.state = state;//目标对象状态发生改变

        setChanged();//表示目标对象已经做了更改
        notifyObservers(state);//通知所有观察者
    }
}

具体观察者：

public class ConcreteObserver implements Observer{
    private int mystate;
    public void update(Observable o, Object arg) {
        mystate=((ConcreteSubject)o).getState();
        System.out.println("观察者接收到的状态:"+mystate);
    }
}

客户端：

public class Client {
    public static void main(String[] args) {
        //创建具体主题
        ConcreteSubject cs=new ConcreteSubject();

        //创建观察者
        ConcreteObserver observer1=new ConcreteObserver();
        ConcreteObserver observer2=new ConcreteObserver();
        ConcreteObserver observer3=new ConcreteObserver();

        //将观察者加入到目标对象观察者集合
        cs.addObserver(observer1);
        cs.addObserver(observer2);
        cs.addObserver(observer3);

        //目标对象改变
        cs.setState(100);
    }
}

输出结果：

这里写图片描述