观察者模式

Observer模式的意图是“定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新”。从这段话里我们可以得到两个信息,如下: 

1, 观察者(具体执行操作的对象,有多个) 

2, 被观察者(顾名思义是被观察的对象,如果该对象发生某些变化则通知观察者执行对应的操)


这个图是观察者模式的真实体现,在这个图中有两个类,java.util.Observable,在我们实现观察者模式的时候,我们的被观察者应该继承这个类,这个observable类把持住了被观察者所持有的观察者列表: 

Java代码  复制代码
  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. }  


这里只列出了一些常用的操作,大家如有不明白可以自己看 java .util包下的Observable,每一个方法前都有详细的解释。但是以上列出的方法对于这个例子来说已经够用了。 

当我们自己的被观察者继承这个Observable类是,我们就自动的获取到被观察者的一切条件了。很方便是不是,这也是为什么sun要把Observable放到 java .util包中的原因,就是为了方便开发者。 

讲完了被观察者再让我们来看看观察者,在上面的代码中有一个addObserver(Observer o)方法,由此我们可以看出来,给被观察者添加观察者时就是用这个方法,那么也就是说观察者一定是Observer的子类或者实现,我们看一下 java .util.Observer吧: 
Java代码  复制代码
  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. }  

很好,这是一个接口,接口中就只有一个方法,update,方法中有两个参数,Observable和一个object,第一个参数就是被观察的对象,而第二个参数就得看业务需求了,需要什么就传进去什么。我们自己的观察者类必须实现这个方法,这样在被观察者调用notifyObservers操作时被观察者所持有的所有观察者都会执行update操作了(当然如果你override这个方法,你甚至可以指定何种情况下只执行某种observer了,是不是比较像责任链模式了)。 

那么到这里我们也差不多可以把 观察者模式 应用到项目中去了。首先让我们来实现被观察者(因为实现被观察者非常简单) 

首先让我们来实现一个发送邮件的观察者: 
Java代码  复制代码
  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. }  

接着再让我们来实现一个发送jms消息的观察者: 
Java代码  复制代码
  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. }  

如上所见,观察者的实现完全跟业务相关。是否复杂就得看你得业务是否复杂了。 

接下来让我们再来实现被观察者,示例如下: 
Java代码  复制代码
  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. }  

到此为止,我们已经简单得实现了 观察者模式 ,让我们来运行一下上面main方法,运行结果如下: 

发送消息给jms服务器的观察者已经被执行 
发送邮件的观察者已经被执行
 

有了jdk对 观察者模式 的支持,程序员在实现基本的 观察者模式 时应该说是易如反掌,这也从一个侧面反应出 观察者模式 的地位,它的地位应该是非常重要的,引用Nicholas Lesiecki(此人是上面所指的ibm那篇文章的作者)的话说,它是“设计模式中的皇后”。 


  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
环境:Windows XP professional, JDK 1.6, Eclipse 3.3 Europa. 我们说学习Java应该从Swing开始,那么学习Swing最重要的思想就是对于观察者模式的理解(Observer Pattern)。因为,该设计模式在Java Swing框架中贯穿了始终。对于C#的委托、代理概念所使用的Callback(回调模式--参见本人的“第一个C#程序Hello World ”资源)来看,Java Swing编程是纯粹的OO语言、是一种非常优雅的编程语言(本人认为)--而C#的学习好像非常强调所谓的OO思想,但是不是知道是什么OO思想?(个人观点,请勿激动)。 该示例是翻写一老外Observer Pattern的例子,本人觉得该示例是对该模式的非常精典的说明,于是花点功夫来翻写它,因为他的代码没有注释说明该模式的设计思想怎样体现在代码中去,所以,本人结合代码注释了关键代码的中文意义说明作者怎样表示该设计模式的,以方便Java程序员阅读和理解代码,从而理解该设计模式的思想(本人的注释非常详尽)。 目的,本人认为,作为Java程序员--不是指只会使用JBuilder(或者Websphare等)工具拖拽的java操作员--我们指至少能使用Eclipse工具书写Swing代码的Java编程员,或者使用ant工具编程的Java程序员,应该熟练掌握该设计模式!因为该设计模式贯穿Swing框架的始终。 阅读对象:本锦江中心中从S1阶段就想成为一个Java程序员的学员,并且在S1阶段已经非常认真的学习Java编程的学员。 注:不过该代码应该是本锦江中心Y2阶段Java方向学习的学员的参考代码,因为,该代码是由Y2阶段本教员会讲解。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值