Java 设计模式之观察者模式

一、概述

观察者模式是对象的行为模式，又叫发布-订阅(Publish/Subscribe)模式、模型-视图(Model/View)模式、源-监听器(Source/Listener)模式或从属者(Dependents)模式。

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

 UML 类图

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

Observer：抽象观察者，为所有具体的观察者定义一个接口，在得到主题的通知时更新自己。这个接口方法叫做更新接口。抽象观察者一般用一个抽象类或者一个接口实现。更新接口通常包含一个update 方法，这个方法叫更新方法。

ConcreteSubject：具体主题或者具体通知者，将有关状态存入具体观察者对象，在具体主题的内部状态改变时，给所有等级过得观察者发出通知。具体主题角色通常用一个具体子类实现。

ConcreteObserver：具体观察者，实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态相互。具体观察者角色可以保持一个指向具体主题对象的引用。具体观察者角色通常用一个具体子类实现。

 

二、实例

代码：

Subject

/**
* 被观察者  Subject：
* 目标知道它的观察者。可以有任意多个观察者观察同一个目标  
* 提供注册和删除观察者对象的接口
*/
public interface IWorker {
 
    void attach(IPlayer mObserver);
 
    void detach(IPlayer mObserver);
 
    // 这种是推模型
    // 拉模型通常都是把主题对象当做参数传递 void notice(IPlayer player)
    void notice();
}　

 

具体的被观察者

/**
* 具体的被观察者
*/
public class Worker implements IWorker {
 
    private List<IPlayer> players;
 
    private String tactical;
    private String train;
 
    public Worker() {
        players = new ArrayList<IPlayer>();
    }
 
    @Override
    public void attach(IPlayer mObserver) {
        players.add(mObserver);
    }
 
    @Override
    public void detach(IPlayer mObserver) {
        int i = players.size();
        if (i > 0)
            players.remove(mObserver);
    }
 
    @Override
    public void notice() {
        for (int i = 0; i < players.size(); i++) {
            players.get(i).update(tactical, train);
        }
    }
 
    public void setNotice(String tactical, String train) {
        this.tactical = tactical;
        this.train = train;
        // 信息更新完毕，通知所有的观察者
        notice();
    }
 
}

Observer

/**
* 观察者 Observer： 为那些在目标发生改变时需要获得通知的对象定义一个更新接口。
*/
public interface IPlayer {
    void update(String tactical, String train);
}

具体的观察者

/**
* 具体的观察者
*/
public class Player implements IPlayer {
    private String name;
    private String tactical;
    private String train;
 
    public Player(String name) {
        this.name = name;
    }
 
    @Override
    public void update(String tactical, String train) {
        this.tactical = tactical;
        this.train = train;
        todayPlay();
    }
 
    public void todayPlay() {
        System.out.println(name + "今天安排：" + tactical + "," + train);
    }
 
}
 
Client
public class Client {
    public static void main(String[] args) {
        Worker worker = new Worker();
        IPlayer messi = new Player("messi");
        IPlayer cluo = new Player("cluo");
        worker.attach(messi);
        worker.attach(cluo);
        worker.detach(messi);
        worker.setNotice("首发", "盘带");
    }
}

结果：

 

三、总结：

通过上面的例子可以看出，Worker 和 Player 两者处于松耦合状态，甚至是零耦合状态，如果某一需求改变了，需要进行代码的修改，这并不会涉及到另一者，这是非常好的松耦合设计，只需要实现接口就好。

 

在观察者模式中又有两种模型，推模型和拉模型

• 推模型：被观察者向观察者推送自身的详细信息，不管观察者是否需要，推送的信息通常是主题对象的全部或部分数据
• 拉模型：被观察者通过把自身的引用传递给观察者，需要观察者自行通过该引用来获取相关的信息。我们上面的例子使用的就是推模型。把Worker 的两个成员变量推送给观察者Player，如果要把上面的例子改成拉模型也可以，只需要把notice() 方法改为notice(IPlayer play) 即可。
• Java 提供的对观察者模式的支持就是拉模式， 在JAVA语言的java.util库里面，提供了一个Observable类以及一个Observer接口，构成JAVA语言对观察者模式的支持。

被观察者：

public class Watched extends Observable {
    private String data = "123";
 
    public String getData() {
        return data;
    }
 
    public void setData(String data) {
        if (this.data.equals(data)) {
            this.data = data;
            setChanged();
        }
        notifyObservers();
    }
}

观察者：

public class Watcher implements Observer {
    public Watcher(Observable o) {
        // 将该观察者放入待通知观察者里
        o.addObserver(this);
    }
 
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("状态发生改变：" + ((Watched) o).getData());
    }
}

客户端：

public class WatchClient {
    public static void main(String[] args) {
        // 创建被观察者对象
        Watched watched = new Watched();
        // 创建观察者对象，并将被观察者对象登记
        Watcher watcher = new Watcher(watched);
        // 给被观察者状态赋值
        watched.setData("123");
        watched.setData("abc");
        watched.setData("!@#");
    }
}

结果：

 

两者区别：

• 推模型是假定主题对象知道观察者需要的数据；而拉模型是主题对象不知道观察者具体需要什么数据，没有办法的情况下，干脆把自身传递给观察者，让观察者自己去按需要取值
• 推模型可能会使得观察者对象难以复用，因为观察者的update()方法是按需要定义的参数，可能无法兼顾没有考虑到的使用情况。这就意味着出现新情况的时候，就可能提供新的update()方法，或者是干脆重新实现观察者；而拉模型就不会造成这样的情况，因为拉模型下，update()方法的参数是主题对象本身，这基本上是主题对象能传递的最大数据集合了，基本上可以适应各种情况的需要。

经过上面的几个例子，相信大家对观察者模式有了一个比较深刻的认识了，最后我们再说说观察者模式可以用在什么地方。比如我们有两个对象，一个对象依赖于另一个对象的变化而变化，此时我们可以将这两个对象抽象出来，做成接口，利用观察者模式来进行解耦，又或者，当一个对象发生变化的时候，需要通知别的对象来做出改变，但又不知道这样的对象有多少个，此时利用观察者模式非常合适。Javaweb 的Listener 的实现思想就是这样的。