学习：java设计模式—Observer模式

简单地说，观察者模式定义了一个一对多的依赖关系，让一个或多个观察者对象监察一个主题对象。这样一个主题对象在状态上的变化能够通知所有的依赖于此对象的

那些观察者对象，使这些观察者对象能够自动更新。

　　一、观察者模式的结构

　　本模式的类图结构如下：

            图1、观察者模式的静态结构可从类图中看清楚。

　　在观察者模式里有如下的角色：

　　. 抽象主题（Subject）角色：主题角色把所有的观察者对象的引用保存在一个列表里；每个主题都可以有任何数量的观察者。主题提供一个接口可以加上或撤销观察者对象；

            图2、抽象主题角色，有时又叫做抽象被观察者角色，可以用一个抽象类或者一个接口实现；在具体的情况下也不排除使用具体类实现。

　　. 抽象观察者（Observer）角色：为所有的具体观察者定义一个接口，在得到通知时更新自己；

            图3、抽象观察者角色，可以用一个抽象类或者一个接口实现；在具体的情况下也不排除使用具体类实现。

　　. 具体主题（ConcreteSubject）角色：保存对具体观察者对象有用的内部状态；在这种内部状态改变时给其观察者发出一个通知；

            图4、具体主题角色，通常用一个具体子类实现。

　　．具体观察者（ConcreteObserver）角色：保存一个指向具体主题对象的引用；和一个与主题的状态相符的状态。具体观察者角色实现抽象观察者角色所要求的更新自己的接口，以便使本身的状态与主题的状态自恰。

            图5、具体观察者角色，通常用一个具体子类实现。

　二、示意性实现的Java代码

首先在这个示意性的实现里，用一个Java接口实现抽象主题角色，这就是下面的Subject接口：

public interface Subject
            {
　　public void attach(Observer observer);

　　public void detach(Observer observer);

　　void notifyObservers();
            }代码清单1、Subject接口的源代码。

　　这个抽象主题接口规定出三个子类必须实现的操作，即 attach() 用来增加一个观察者对象；detach() 用来删除一个观察者对象；和notifyObservers() 用来通知各个观察者刷新它们自己。抽象主题角色实际上要求子类保持一个以所有的观察者对象为元素的列表。

　　具体主题则是实现了抽象主题Subject接口的一个具体类。


import java.util.Vector;
            import java.util.Enumeration;

            public class ConcreteSubject implements Subject
            {
　　private Vector observersVector = new java.util.Vector();
　　public void attach(Observer observer)
　　{  //添加观察者
            　　　　observersVector.addElement(observer);
　　}

　　public void detach(Observer observer)
　　{ //删除该观察者
            　　　　observersVector.removeElement(observer);
　　}

　　public void notifyObservers()
　　{  //遍历观察者向量，通知每个观察者
            　　　　Enumeration enumeration = observers();
　　　　while (enumeration.hasMoreElements())
　　　　{
　　　　　　((Observer)enumeration.nextElement()).update();
　　　　}
　　}

　　public Enumeration observers()
　　{
　　　　return (（Vector) observersVector.clone()).elements();
　　}
            }代码清单2、ConcreteSubject类的源代码。

　　抽象观察者角色的实现实际上是最为简单的一个，它是一个Java接口，只声明了一个方法，即update()。这个方法被子类实现后，一被调用便刷新自己。

public interface Observer
            {
　　void update();
            }代码清单3、Observer接口的源代码。

　　具体观察者角色的实现其实只涉及update()方法的实现。这个方法怎么实现与应用密切相关，因此本类只给出一个框架。
public class ConcreteObserver implements Observer
            {
　　public void update()
　　{
　　　　// Write your code here，一般来说Observer还有一个指向主题的引用，在这个方法中可以通过它，来判断自己关注的数据是否发生变化，并作出相应的行动
            　　}
            }

代码清单4、ConcreteObserver类的源代码。

　　

三、Java语言提供的对观察者模式的支持

　　虽然观察者模式的实现方法可以有设计师自己确定，但是因为从AWT1.1开始视窗系统的事件模型采用观察者模式，因此观察者模式在Java语言里的地 位较为重要。正因为这个原因，Java语言给出了它自己对观察者模式的支持。因此，本文建议读者在自己的系统中应用观察者模式时，不妨利用Java语言所 提供的支持。

　　在Java语言的java.util库里面，提供了一个Observable类以及一个Observer接口，构成Java语言对观察者模式的支持。

　　Observer接口

　　这个接口只定义了一个方法，update()。当被观察者对象的状态发生变化时，这个方法就会被调用。这个方法的实现应当调用每一个被观察者对象的notifyObservers()方法，从而通知所有的观察对象。

            图6、java.util提供的Observer接口的类图。

package java.util;

            public interface Observer
            {
　　/**
　　* 当被观察的对象发生变化时，这个方法会被调用。
            　　*/
　　void update(Observable o, Object arg);
            }代码清单5、java.util.Observer接口的源代码。

　　Observable类

　　被观察者类都是java.util.Observable类的子类。java.util.Observable提供公开的方法支持观察者对象，这些方 法中有两个对Observable的子类非常重要：一个是setChanged()，另一个是notifyObservers()。第一个方法setChanged()被调用之后会设置一个内部标记变量，代表被观察者对象的状态发生了变化。第二个是notifyObservers()，这个方法 被调用时，会调用所有登记过的观察者对象的update()方法，使这些观察者对象可以更新自己。

　　java.util.Observable类还有其它的一些重要的方法。比如，观察者对象可以调用java.util.Observable类的addObserver()方法，将对象一个一个加入到一个列表上。当有变化时，这个列表可以告诉notifyObservers()方法那些观察者对象 需要通知。由于这个列表是私有的，因此java.util.Observable的子对象并不知道观察者对象一直在观察着它们。


            图7、Java语言提供的被观察者的类图。
　　被观察者类Observable的源代码：

package java.util;
publicclass Observable
{
privateboolean changed= false;
private Vector obs;

/** 用0个观察者构造一个被观察者。**/

public Observable()
{
obs= new Vector();
}

/**
* 将一个观察者加到观察者列表上面。
*/
publicsynchronized void addObserver(Observer o)
{
if (!obs.contains(o))
{
obs.addElement(o);
}
}

/**
* 将一个观察者对象从观察者列表上删除。
*/
publicsynchronized void deleteObserver(Observer o)
{
obs.removeElement(o);
}

/**
* 相当于 notifyObservers(null)
*/
publicvoid notifyObservers()
{
notifyObservers(null);
}

/**
* 如果本对象有变化（那时hasChanged 方法会返回true）
* 调用本方法通知所有登记在案的观察者，即调用它们的update()方法，
* 传入this和arg作为参量。
*/
publicvoid notifyObservers(Object arg)
{
/**
* 临时存放当前的观察者的状态。参见备忘录模式。
*/
Object[] arrLocal;

synchronized (this)
{
if (!changed)return;
arrLocal= obs.toArray();
clearChanged();
}

for (int i= arrLocal.length-1; i>=0; i--)
((Observer)arrLocal[i]).update(this, arg);
}

/**
* 将观察者列表清空
*/
publicsynchronized void deleteObservers()
{
obs.removeAllElements();
}

/**
* 将“已变化”设为true
*/
protectedsynchronized void setChanged()
{
changed= true;
}

/**
* 将“已变化”重置为false
*/
protectedsynchronized void clearChanged()
{
changed= false;
}

/**
* 探测本对象是否已变化
*/
publicsynchronized boolean hasChanged()
{
return changed;
}

/**
* 返还被观察对象（即此对象）的观察者总数。
*/
publicsynchronized int countObservers()
{
return obs.size();
}
}

代码清单6、java.util.Observer接口的源代码。

　　这个Observable类代表一个被观察者对象。一个被观察者对象可以有数个观察者对象，一个观察者可以是一个实现Observer接口的对象。在 被观察者对象发生变化时，它会调用Observable的notifyObservers方法，此方法调用所有的具体观察者的update()方法，从而 使所有的观察者都被通知更新自己。见下面的类图：


            图8、使用Java语言提供的对观察者模式的支持。

　　发通知的次序在这里没有指明。Observerable类所提供的缺省实现会按照Observers对象被登记的次序通知它们，但是Observerable类的子类可以改掉这一次序。子类并可以在单独的线程里通知观察者对象；或者在一个公用的线程里按照次序执行。

　　当一个可观察者对象刚刚创立时，它的观察者集合是空的。两个观察者对象在它们的equals()方法返回true时，被认为是两个相等的对象。
　　　

四、观察者模式的总结

　　观察者模式的效果有以下的优点：

　　第一、观察者模式在被观察者和观察者之间建立一个抽象的耦合。被观察者角色所知道的只是一个具体观察者列表，每一个具体观察者都符合一个抽象观察者的接口。被观察者并不认识任何一个具体观察者，它只知道它们都有一个共同的接口。

　　由于被观察者和观察者没有紧密地耦合在一起，因此它们可以属于不同的抽象化层次。如果被观察者和观察者都被扔到一起，那么这个对象必然跨越抽象化和具体化层次。

　　第二、观察者模式支持广播通讯。被观察者会向所有的登记过的观察者发出通知，

　　观察者模式有下面的缺点：

　　第一、如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。

　　第二、如果在被观察者之间有循环依赖的话，被观察者会触发它们之间进行循环调用，导致系统崩溃。在使用观察者模式是要特别注意这一点。

　　第三、如果对观察者的通知是通过另外的线程进行异步投递的话，系统必须保证投递是以自恰的方式进行的。

　　第四、虽然观察者模式可以随时使观察者知道所观察的对象发生了变化，但是观察者模式没有相应的机制使观察者知道所观察的对象是怎么发生变化的。

　　观察者模式与其它模式的关系

　　观察者模式使用了备忘录模式(Memento Pattern)暂时将观察者对象存储在被观察者对象里面。

　　问答题

　　第一题、我和妹妹跟妈妈说：“妈妈，我和妹妹在院子里玩；饭做好了叫我们一声。”请问这是什么模式？能否给出类图说明？

　　问答题答案

　　第一题答案、这是观察者模式。我和妹妹让妈妈告诉我们饭做好了，这样我们就可以来吃饭了。换用较为技术化的语言来说，当系统的主题（饭）发生变化时， 就告诉系统的其它部份（观察者们，也就是妈妈、我和妹妹），使其可以调整内部状态（有开始吃饭的准备），并采取相应的行动（吃饭）。

　　系统的类图说明如下。


            图11、系统的类图。