观察者模式

 
观察者模式
何时使用对象间的一种一对多的依赖关系一个对象(观察目标对象)的状态发生改变,所有依赖于它的对象(观察者对象)都将得到通知,使这些观察者对象能够自动更新(即使用推送方式
如何解决:观察目标类里有一个 ArrayList 存放观察者们
优点: 1、观察者和被观察者是抽象耦合的。 2、建立一套触发机制。
缺点: 1、如果一个被观察者对象有很多的直接和间接的观察者的话,将所有的观察者都通知到会花费很多时间。 2、如果在观察者和观察目标之间有循环依赖的话,观察目标会触发它们之间进行循环调用,可能导致系统崩溃。
注意事项: 1、JAVA 中已经有了对观察者模式的支持类。(java.util.Observable类:监听目标需要继承这个类java.util.Observer接口,监听者需要实现这个接口) 2、避免循环引用。 3、如果顺序执行,某一观察者错误会导致系统卡壳,一般采用异步方式
 
例子
  1. import java.util.ArrayList;
  2. import java.util.List;
  3.  
  4. publicclassSubject{
  5.  
  6.    privateList<Observer> observers
  7.       =newArrayList<Observer>();
  8.    privateint state;
  9.  
  10.    publicint getState(){
  11.       return state;
  12.    }
  13.  
  14.    publicvoid setState(int state){
  15.       this.state = state;
  16.       notifyAllObservers(state);
  17.    }
  18.  
  19.    publicvoid attach(Observer observer){
  20.       observers.add(observer);       
  21.    }
  22.  
  23.    publicvoid notifyAllObservers(int state){
  24.       for(Observer observer : observers){
  25.          observer.update(int state);
  26.       }
  27.    }    
  28. }
 
推模型与拉模型
  • 推模型
    主题对象向观察者推送主题的详细信息,不管观察者是否需要,推送的信息通常是主题对象的全部或部分数据。(通过参数传递数据)。上面的例子就是推模型。
  • 拉模型
    主题对象在通知观察者的时候,只传递少量信息。如果观察者需要更具体的信息,由观察者主动到主题对象中获取,相当于是观察者从主题对象中拉数据。一般这种模型的实现中,会把主题对象自身通过update()方法传递给观察者,这样在观察者需要获取数据的时候,就可以通过这个引用来获取了。
  1.  public interface Observer{
  2.     /**
  3.      * 更新接口
  4.      * @param subject 传入主题对象,方便获取相应的主题对象的状态
  5.      */
  6.     publicvoid update(Subject subject);
  7. }
  • 两种模型的比较
  1. 推模型是假定主题对象知道观察者需要的数据;而拉模型是主题对象不知道观察者具体需要什么数据,没有办法的情况下,干脆把自身传递给观察者,让观察者自己去按需要取值。
  2.  推模型可能会使得观察者对象难以复用,因为观察者的update()方法是按需要定义的参数,可能无法兼顾没有考虑到的使用情况。这就意味着出现新情况的时候,就可能提供新的update()方法,或者是干脆重新实现观察者;而拉模型就不会造成这样的情况,因为拉模型下,update()方法的参数是主题对象本身,这基本上是主题对象能传递的最大数据集合了,基本上可以适应各种情况的需要。
 
JAVA中的观察者模式的支持类
  • java.util.Observable 这是一个类,而非接口,监听目标需要继承这个类。
  • java.util.Observer 这是一个接口,监听者需要实现这个接口。
 
示例代码:
  1. 将consumer加入主题provider的观察者行列
  2. provider设置状态变化,通知持有的观察者
  3. 观察者consumer收到通知,打印日志处理
  1. import java.util.Observable;
  2. import java.util.Observer;
  3. publicclassMainRoot{
  4.   publicstaticvoid main(String[] args){
  5.       Observer consumer =newConsumer();
  6.       MilkProvider provider =newMilkProvider();
  7.       provider.addObserver(consumer);
  8.       provider.milkProduced();
  9.   }
  10.  
  11.   staticclassMilkProvider extends Observable{
  12.       publicvoid milkProduced(){
  13.           setChanged();//状态改变,必须调用
  14.           notifyObservers();
  15.       }
  16.   }
  17.  
  18.   staticclassConsumer implements Observer{
  19.       @Override
  20.       publicvoid update(Observable arg0,Object arg1){
  21.           System.out.println("Consumer update..."+ arg0 +";arg1="+ arg1);
  22.       }
  23.   }
  24. }
 
JAVA源码
  • java.util.Observer 接口
  1. public interface Observer{
  2.     void update(Observable o,Object arg);
  3. }
  • java.util.Observable类
  1. publicclassObservable{
  2.     private boolean changed =false;
  3.     privateVector obs;
  4.  
  5.     publicObservable(){
  6.         obs =newVector();
  7.     }
  8.  
  9.    // 将一个观察者添加到观察目标中
  10.     public synchronized void addObserver(Observer o){
  11.         if(o == null)
  12.             thrownewNullPointerException();
  13.         if(!obs.contains(o)){
  14.             obs.addElement(o);
  15.         }
  16.     }
  17.  
  18.     //将一个观察者从观察目标中删除
  19.     public synchronized void deleteObserver(Observer o){
  20.         obs.removeElement(o);
  21.     }
  22.  
  23.     publicvoid notifyObservers(){
  24.         notifyObservers(null);
  25.     }
  26.  
  27.      /* 如果本对象有变化(hasChanged 方法返回true),调用本方法通知所有登记的观察者,
  28.          即调用它们的update()方法,传入this和arg作为参数 */
  29.     publicvoid notifyObservers(Object arg){
  30.  
  31.         Object[] arrLocal;
  32.         synchronized (this){
  33.              if(!changed)
  34.                     return;
  35.              arrLocal = obs.toArray();
  36.              clearChanged();
  37.         }
  38.         for(int i = arrLocal.length-1; i>=0; i--)
  39.              ((Observer)arrLocal[i]).update(this, arg);
  40.     }
  41.  
  42.     //将观察者聚集清空
  43.     public synchronized void deleteObservers(){
  44.         obs.removeAllElements();
  45.     }
  46.  
  47.     //将“已变化”设置为true
  48.     protected synchronized void setChanged(){
  49.         changed =true;
  50.     }
  51.     //将“已变化”重置为false
  52.     protected synchronized void clearChanged(){
  53.     changed =false;
  54.     }
  55.     // 检测本对象是否已变化
  56.     public synchronized boolean hasChanged(){
  57.     return changed;
  58.     }
  59.     public synchronized int countObservers(){
  60.         return obs.size();
  61.     }
  62. }
参考来源:《JAVA与模式》之观察者模式:http://www.cnblogs.com/java-my-life/archive/2012/05/16/2502279.html (观察者模式的结构、观察者模式的推模型和拉模型、JAVA对观察者模式的支持
 
 
 
 





posted @ 2016-06-27 18:20  _Doing  阅读(255)  评论(0编辑  收藏  举报