java observer和observable 实现观察者模式

在Java中通过Observable类和Observer接口实现了观察者模式。一个Observer对象监视着一个Observable对象的变化，当Observable对象发生变化时，Observer得到通知，就可以进行相应的工作。例如在文档/视图结构中，文档被修改了，视图就会得到通知。

      java.util.Observable中有两个方法对Observer特别重要，一个是setChange()方法用来设置一个内部标志位注明数据发生了变化；一个是notifyObservers()方法会去调用一个列表中所有的Observer的update()方法，通知它们数据发生了变化。

       Observer通过Observable的addObserver()方法把自己添加到这个列表中 。这个列表虽然由Observable拥有，但Observable并不知道到底有哪些Observer正在观察等待通知。Observable只提供一个方法让Observer能把自己添加进列表，并保证会去通知Observer发生了变化。通过这种机制，可以有任意多个Observer对Observable进行观察，而不影响Observable的实现。

一个简单例子：

[java]  view plain copy

[java]  view plain copy

1. import java.util.Observable;  
2. public class SimpleObservable extends Observable  
3. {  
4.    private int data = 0;  
5.    public int getData(){   
6.        return data;  
7.    }  
8.    public void setData(int i){  
9.        if(this.data != i){ this.data = i; setChange();}  
10.           notifyObservers();  
11.          //只有在setChange()被调用后，notifyObservers()才会去调用update()，否则什么都不干。  
12.        }  
13.    }  
14. }  
15. import java.util.Observable;  
16. import java.util.Observer;  
17. public class SimpleObserver implements Observer  
18. {  
19.    public SimpleObserver(SimpleObservable so){  
20.       so.addObserver(this );  
21.    }  
22.    public void update(Observable o,Object arg){  
23.       System.out.println(“Data has changed to” + (SimpleObservable)o.getData());  
24.    }  
25. }  
26. public class SimpleTest  
27. {  
28.    public static void main(String[] args){  
29.       SimpleObservable doc = new SimpleObservable ();  
30.       SimpleObserver view = new SimpleObserver (doc);  
31.       doc.setData(1);  
32.       doc.setData(2);  
33.       doc.setData(2);  
34.       doc.setData(3);   
35.    }  
36. }  

Data has changed to 1 

Data has changed to 2  //第二次setData(2)时由于没有setChange，所以update没被调用

Data has changed to 3 

      Observable类有两个私有变量。一个boolean型的标志位，setChange()将它设为真，只有它为真时，notifyObservers方法才会调用Observer的update方法，clearChange()设标志位为假，hasChange返回当前标志位的值。另一个是一个Vector，保存着一个所有要通知的Observer列表，addObserver添加Observer到列表，deleteObserver从列表中删除指定Observer，deleteObservers清空列表，countObservers返回列表中Observer的数目， 在Observer对象销毁前一定要用deleteObserver将其从列表中删除，不然因为还存在对象引用的关系，Observer对象不会被垃圾收集，造成内存泄漏，并且已死的Observer仍会被通知到，有可能造成意料外的错误，而且随着列表越来越大，notifyObservers操作也会越来越慢。    

      Observable的所有方法都是同步的，保证了在一个线程对其标志位、列表进行操作时，不会有其它线程也在操作它。

      Observable的notifyObservers(Object obj)形式可以再调用update时将参数传进去。

通知顺序通常时越晚加入列表的越先通知。update会被依次调用，由于一个update返回后下一个update才被调用，这样当update中有大量操作时，最好将其中的工作拿到另一个线程或者Observer本身同时也是一个Thread类，Observer先挂起，在update中被唤醒，这样会有一个隐患，Observer线程还没来得及挂起，update就被调用了，通知消息就这样被错过了，一种解决办法是在Observer中实现一个同步的队列结构，并有一个类来封装参数，update实现一个参数类的对象把接收到的通知消息的参数封装在里面，然后把其加进队列，run方法从队列中移除参数对象，并进行处理，这保证了没有通知信息被丢失。

 在多线程时，只有Observer会与单线程不同，Observable不需任何改变来支持多线程，因为它又很多作为单独线程运作的Observer。

一个多线程例子：

[java]  view plain copy

1. import java.util.*;  
2. public class SimpleObserverEx extends Thread implements Observer  
3. {  
4.    Queue queue;//利用一个消息队列来接收Observable的通知，保证消息不会丢失  
5.    public void run(){  
6.       while(true){  
7.          ArgPack a = (ArgPack) queue.dequeue();  
8.          Observable o = a.o;  
9.          Object obj = a.arg;  
10.          //…执行相应的工作  
11.       }  
12.    }  
13.    public void update(Observable o, Object arg){  
14.       ArgPack a = new ArgPack (o,arg);  
15.       queue.queue(a);  
16.    }  
17. }  
18. import java.util.*;  
19. public class Queue extends LinkedList{  
20.    public synchronized void queue(Object o){  
21.       addLast(o);   
22.       notify();  
23.    }  
24.    public synchronized void dequeue(){  
25.       while(this.isEmpty()){  
26.          try{   
27.             wait();  
28.          }  
29.          catch(InterruptedException el){  
30.          }  
31.       }  
32.       Object o;  
33.       try{   
34.          o =this.removeFirst();  
35.       }  
36.       catch(NoSuchElementException){  
37.          o = null;  
38.       }  
39.       return o;  
40.    }   
41. }  
42. public class ArgPack  
43. {  
44.    public Observable o;  
45.    public Object obj;  
46.    public ArgPack (Observable o,Object obj){  
47.       this.o = o;this.obj = obj;  
48.    }  
49. }  

Observable是一个类而不是一个接口这限制了它的使用，一个解决的办法是在一个Observable类中把我们的类包装进去(把我们的类实例当作Observable的域),因为Observable中的setChange是一个protected方法，我们没法在外面调用它。所以没法在我们的类中包装一个Observable，但是如果我们的类中同样也有protected方法，那这个办法就无法使用.

ContentObserver类详解: 

http://blog.csdn.net/qinjuning/article/details/7047607 

下面2个工程是Observable与Observer的经典运用,是android实现的单指拖动放大图片的操作

两个例子：

http://dl.iteye.com/topics/download/4ba47648-c754-303f-8fa0-49d4086a8784

http://dl.iteye.com/topics/download/1a09cda1-3b22-3e2e-bd90-01d11a420316