• 观察者模式


     
    观察者模式
    何时使用对象间的一种一对多的依赖关系一个对象(观察目标对象)的状态发生改变,所有依赖于它的对象(观察者对象)都将得到通知,使这些观察者对象能够自动更新(即使用推送方式
    如何解决:观察目标类里有一个 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对观察者模式的支持
     
     
     
     





  • 相关阅读:
    【安卓本卓】Android系统源码篇之(一)源码获取、源码目录结构及源码阅读工具简介
    【朝花夕拾】Android性能篇之(六)Android进程管理机制
    【烂笔头】adb命令篇
    【朝花夕拾】Android性能篇之(五)Android虚拟机
    【朝花夕拾】Android性能篇之(一)序言及JVM
    【烂笔头】git常用命令篇
    【朝花夕拾】Android性能篇之(四)Apk打包
    【朝花夕拾】Android Log篇
    从2015年百度站长的一则公告回头看百度的骚操作
    ASP.NET Core+Quartz.Net 实现web定时任务
  • 原文地址:https://www.cnblogs.com/Doing-what-I-love/p/5621157.html
Copyright © 2020-2023  润新知