观察者模式

1. /**  
2.  * @author 张荣华(ahuaxuan)  
3. * @version $Id$  
4.  */  
5. public class Subject extends Observable{   
6.        
7.     /**  
8.      * 业务方法，一旦执行某个操作，则通知观察者  
9.      */  
10.     public void doBusiness(){   
11.         if (true) {   
12.             super.setChanged();   
13.         }   
14.         notifyObservers("现在还没有的参数");   
15.     }   
16.   
17.        
18.     public static void main(String [] args) {   
19.         //创建一个被观察者   
20.         Subject subject = new Subject();   
21.            
22.         //创建两个观察者   
23.         Observer mailObserver = new MailObserver();   
24.         Observer jmsObserver = new JMSObserver();   
25.            
26.         //把两个观察者加到被观察者列表中   
27.         subject.addObserver(mailObserver);   
28.         subject.addObserver(jmsObserver);   
29.            
30.         //执行业务操作   
31.         subject.doBusiness();   
32.     }   
33. }  

 

1. /**  
2.  * @author 张荣华(ahuaxuan)  
3.  * @version $Id$  
4.  */  
5. public class JMSObserver implements Observer{   
6.   
7.     public void update(Observable o, Object arg) {   
8.         System.out.println("发送消息给jms服务器的观察者已经被执行");   
9.     }   
10. }  

 

1. /**  
2.  * @author 张荣华(ahuaxuan)  
3. * @version $Id$  
4.  */  
5. public class MailObserver implements Observer{   
6.   
7.     /**  
8.      * 这个类取名为MailObserver，顾名思义，她是一个用来发送邮件的观察者  
9.      */  
10.     public void update(Observable o, Object arg) {   
11.         System.out.println("发送邮件的观察者已经被执行");   
12.     }   
13. }  

 

观察者接口（类）

1. public interface Observer {   
2.     /**  
3.      * This method is called whenever the observed object is changed. An  
4.      * application calls an <tt>Observable</tt> object's  
5.      * <code>notifyObservers</code> method to have all the object's  
6.      * observers notified of the change.  
7.      *  
8.      * @param   o     the observable object.  
9.      * @param   arg   an argument passed to the <code>notifyObservers</code>  
10.      *                 method.  
11.      */  
12.     void update(Observable o, Object arg);   
13. }   
14. } 

 

 

被观察者类

1. public class Observable {   
2.     private boolean changed = false;   
3.     private Vector obs;   
4.       
5.     //创建被观察者时就创建一个它持有的观察者列表，注意，这个列表是需要同步的。   
6.     public Observable() {   
7.     obs = new Vector();   
8.     }   
9.   
10.     /**  
11.      * 添加观察者到观察者列表中去  
12.      */  
13.     public synchronized void addObserver(Observer o) {   
14.         if (o == null)   
15.             throw new NullPointerException();   
16.     if (!obs.contains(o)) {   
17.         obs.addElement(o);   
18.     }   
19.     }   
20.   
21.     /**  
22.      * 删除一个观察者  
23.      */  
24.     public synchronized void deleteObserver(Observer o) {   
25.         obs.removeElement(o);   
26.     }   
27.   
28.     /**  
29.      * 通知操作，即被观察者发生变化，通知对应的观察者进行事先设定的操作，不传参数的通知方法  
30.      */  
31.     public void notifyObservers() {   
32.     notifyObservers(null);   
33.     }   
34.   
35.     /**  
36.      * 与上面的那个通知方法不同的是，这个方法接受一个参数，这个参数一直传到观察者里，以供观察者使用  
37.      */  
38.     public void notifyObservers(Object arg) {   
39.        
40.         Object[] arrLocal;   
41.   
42.     synchronized (this) {   
43.         if (!changed)   
44.                 return;   
45.             arrLocal = obs.toArray();   
46.             clearChanged();   
47.         }   
48.   
49.         for (int i = arrLocal.length-1; i>=0; i--)   
50.             ((Observer)arrLocal[i]).update(this, arg);   
51.     }   
52. }