观察者模式介绍--阎宏（1）

观察者模式介绍

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

观察者模式的结构
　　观察者（Observer）模式是对象的行为型模式，又叫做发表-订阅（Publish/Subscribe）模式、模型-视图（Model/View）模式、源-收听者（Source/Listener）模式或从属者（Dependents）模式。

本模式的类图结构如下：

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

在观察者模式里有如下的角色：
抽象主题（Subject）角色：主题角色把所有的观察者对象的引用保存在一个列表里；每个主题都可以有任何数量的观察者。主题提供一个接口可以加上或撤销观察者对象；主题角色又叫做抽象被观察者(Observable)角色；（体会一下，是被观察者保存观察着的注册信息） 

图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接口的一个具体类，它给出了以上的三个操作的具体实现。从下面的源代码可以看出，这里给出的Java实现使用了一个Java向量来保存所有的观察者对象，而 attach() 和 detach() 操作则是对此向量的元素增减操作。

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
     }
}

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

 

　　虽然观察者模式的实现方法可以有设计师自己确定，但是因为从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;
public class Observable
{
     private boolean changed = false;
     private Vector obs;

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

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

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

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

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

     /**
     * 如果本对象有变化（那时hasChanged 方法会返回true）
     * 调用本方法通知所有登记在案的观察者，即调用它们的update()方法，
     * 传入this和arg作为参量。
     */
     public void 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);
      }

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

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

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

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

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

 

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

 

 

 

 

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

 

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

 

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

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

 

怎样使用Java对观察者模式的支持

　　为了说明怎样使用Java所提供的对观察者模式的支持，本节给出一个非常简单的例子。在这个例子里，被观察对象叫做Watched，也就是被监视者；而观察者对象叫做Watcher。Watched对象继承自java.util.Obsevable类；而Watcher对象实现了java.util.Observer接口。另外有一个对象Tester，扮演客户端的角色。

这个简单的系统的结构如下图所示：

图9、一个使用Observer接口和Observable类的例子

 

在客户端改变Watched对象的内部状态时，Watched就会通知Watcher采取必要的行动。

package com.javapatterns.observer.watching;

import java.util.Observer;

public class Tester
{
     static private Watched watched;
     static private Observer watcher;

     public static void main(String[] args)
     {
          watched = new Watched();

          watcher = new Watcher(watched);

          watched.changeData("In C, we create bugs.");
          watched.changeData("In Java, we inherit bugs.");
          watched.changeData("In Java, we inherit bugs.");
          watched.changeData("In Visual Basic, we visualize bugs."); 
     }
}

 

代码清单7、Tester类的源代码

 

package com.javapatterns.observer.watching;

import java.util.Observable;

public class Watched extends Observable
{
     private String data = "";

     public String retrieveData()
     {
          return data;
     }

     public void changeData(String data)
     {
          if ( !this.data.equals( data) )
          {
               this.data = data;
               setChanged();
          }

          notifyObservers();
     }
}  

代码清单8、Watched类的源代码

package com.javapatterns.observer.watching;

import java.util.Observable;
import java.util.Observer;

public class Watcher implements Observer
{
     public Watcher(Watched w)
     {
          w.addObserver(this);
     }

     public void update( Observable ob, Object arg)
     {
          System.out.println("Data has been changed to: '" + ((Watched)ob).retrieveData() + "'");
     }
} 

代码清单9、Watcher类的源代码

 

可以看出，虽然客户端将Watched对象的内部状态赋值了四次，但是值的改变只有三次：

watched.changeData("In C, we create bugs.");
watched.changeData("In Java, we inherit bugs.");
watched.changeData("In Java, we inherit bugs.");
watched.changeData("In Visual Basic, we visualize bugs."); 

 代码清单10、被观察者的内部状态发生了改变

 

对应地，Watcher对象汇报了三次改变，下面就是运行时间程序打印出的信息：

 

Data has been changed to: 'In C, we create bugs.'
Data has been changed to: 'In Java, we inherit bugs.'
Data has been changed to: 'In Visual Basic, we visualize bugs.'

 

 

代码清单11、运行的结果

 

代码清单11、运行的结果