观察者模式

 

观察者模式

何时使用：对象间的一种一对多的依赖关系，当一个对象（观察目标对象）的状态发生改变，所有依赖于它的对象（观察者对象）都将得到通知，使这些观察者对象能够自动更新（即使用推送方式）。

如何解决：在观察目标类里有一个 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. }

来源：http://www.runoob.com/design-pattern/observer-pattern.html

 

推模型与拉模型

• 推模型

    主题对象向观察者推送主题的详细信息，不管观察者是否需要，推送的信息通常是主题对象的全部或部分数据。（通过参数传递数据）。上面的例子就是推模型。

• 拉模型

    主题对象在通知观察者的时候，只传递少量信息。如果观察者需要更具体的信息，由观察者主动到主题对象中获取，相当于是观察者从主题对象中拉数据。一般这种模型的实现中，会把主题对象自身通过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. }

（来源：http://droidyue.com/blog/2015/06/27/desgign-pattern-observer/index.html）

 

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.     }
52.     //将“已变化”重置为false
53.     protected synchronized void clearChanged(){
54.     changed =false;
55.     }
57.     // 检测本对象是否已变化
58.     public synchronized boolean hasChanged(){
59.     return changed;
60.     }
62.     public synchronized int countObservers(){
63.         return obs.size();
64.     }
65. }

参考来源：《JAVA与模式》之观察者模式：http://www.cnblogs.com/java-my-life/archive/2012/05/16/2502279.html （观察者模式的结构、观察者模式的推模型和拉模型、JAVA对观察者模式的支持）

 

 

 

 

来自为知笔记(Wiz)