Java实现观察者模式

观察者模式简介：

定义：定义对象间的一对多的依赖关系，当一个对象的状态改变时，所有依赖于它的对象都得到通知并被自动更新。

原理：由四部分组成抽象目标类，具体目标类，抽象观察者类，具体观察者类

Subject .java

public interface Subject{   
      void attach(Observer observer);//添加观察者   
      void detach(Observer observer);//删除观察者   
      void inform();//通知所有观察者   
}  
public interface Subject{
      void attach(Observer observer);//添加观察者
      void detach(Observer observer);//删除观察者
      void inform();//通知所有观察者
}

ConcreteSubject .java

public class ConcereteSubject implements Subject.java{   
      public void attach(Observer observer){   
            observersVector.addElement(observer);   
      }   
      public void attach(Observer observer){   
            observersVector.removeElement(observer);   
      }   
      public void inform(){   
            //对observersVector中的所有元素调用其update方法   
      }   
}  
public class ConcereteSubject implements Subject.java{
      public void attach(Observer observer){
            observersVector.addElement(observer);
      }
      public void attach(Observer observer){
            observersVector.removeElement(observer);
      }
      public void inform(){
            //对observersVector中的所有元素调用其update方法
      }
}

Observer.java

public interface Observer{   
      void update();//更新观察者   
}  
public interface Observer{
      void update();//更新观察者
}

ConcreteObserver.java

public class ConcreteObserver implements Observer{   
      public void update(){   
      }   
}  
public class ConcreteObserver implements Observer{
      public void update(){
      }
}

使用java.util.Observer接口和java.util.Observable类实现观察者模式：

观察者实现Observer接口，并重写其中的update方法，供被观察者状态改变时调用。

被观察者继承Observable类，在Observable类中有增加，删除观察者类的方法，还有通知所有观察者都update的方法。状态改变时，先setChanged，再notifyObservers。

Observer接口源码：

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

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();    
}    
}  
使用时机：

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

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

3. 观察者模式所做的工作其实就是在解除耦合。让耦合的双方都依赖于抽象，而不是依赖于具体，从而使得各自的变化都不会影响另一边的变化。

本篇文章来源于：http://edu.codepub.com/2009/1102/17225_2.php