Java观察者模式完整实现与剖析

泡在网上的日子 / 文 发表于2012-10-29 21:01 次阅读 观察者模式

 观察者模式用途:定义对象之间的一对多依赖关系,因此,当一个对象的状态发生改变时,其所有依赖项都会得到通知,并自动更新。
它是 OO 设计模式的皇后。该模式被人们广泛应用(特别是在 GUI 应用程序中),并构成了 MVC 架构的关键部分。它处理复杂的问题,而在解决这类问题方面表现得相对较好。

在ibm的技术文章中也有一个老外详细讲解了如何使用aop来增强观察者模式(文章地址见:http://wenku.baidu.com/view/91e13f0b76c66137ee061913.html)。

为了便于理解,首先我举一个现实生活中的例子:在快乐男生比赛过程其实就是观察者的一个体现,可以这样说吉杰是一个被观察者,而杨二,包小柏,还有巫启贤就是3个观察者,被观察者操作(唱歌)时,观察者们就开始操作(评分),被观察者唱歌就是通知观察者们进行评分。

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

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

下面是被观察者代码:

public class Observable {   
    private boolean changed = false;   
    private Vector obs;   
         
    //创建被观察者时就创建一个它持有的观察者列表,注意,这个列表是需要同步的。   
    public Observable() {   
    obs = new Vector();   
    }   
      
    /**   
     * 添加观察者到观察者列表中去   
     */
    public synchronized void addObserver(Observer o) {   
        if (o == null)   
            throw new NullPointerException();   
    if (!obs.contains(o)) {   
        obs.addElement(o);   
    }   
    }   
      
    /**   
     * 删除一个观察者   
     */
    public synchronized void deleteObserver(Observer o) {   
        obs.removeElement(o);   
    }   
      
    /**   
     * 通知操作,即被观察者发生变化,通知对应的观察者进行事先设定的操作,不传参数的通知方法   
     */
    public void notifyObservers() {   
    notifyObservers(null);   
    }   
      
    /**   
     * 与上面的那个通知方法不同的是,这个方法接受一个参数,这个参数一直传到观察者里,以供观察者使用   
     */
    public void notifyObservers(Object arg) {   
          
        Object[] arrLocal;   
      
    synchronized (this) {   
        if (!changed)   
                return;   
            arrLocal = obs.toArray();   
            clearChanged();   
        }   
      
        for (int i = arrLocal.length-1; i>=0; i--)   
            ((Observer)arrLocal[i]).update(this, arg);   
    }   
}

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

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

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

public interface Observer {   
    /**   
     * This method is called whenever the observed object is changed. An   
     * application calls an <tt>Observable</tt> object's   
     * <code>notifyObservers</code> method to have all the object's   
     * observers notified of the change.   
     *   
     * @param   o     the observable object.   
     * @param   arg   an argument passed to the <code>notifyObservers</code>   
     *                 method.   
     */
    void update(Observable o, Object arg);   
}   
}

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

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

首先让我们来实现一个发送邮件的观察者:

/**   
 * @www.jcodecraeer.com  
* @version $Id$   
 */
public class MailObserver implements Observer{   
      
    /**   
     * 这个类取名为MailObserver,顾名思义,她是一个用来发送邮件的观察者   
     */
    public void update(Observable o, Object arg) {   
        System.out.println("发送邮件的观察者已经被执行");   
    }   
}

接着再让我们来实现一个发送jms消息的观察者:

/**   
 * @www.jcodecraeer.com  
 * @version $Id$   
 */
public class JMSObserver implements Observer{   
      
    public void update(Observable o, Object arg) {   
        System.out.println("发送消息给jms服务器的观察者已经被执行");   
    }   
}


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

接下来让我们再来实现被观察者,示例如下:

/**   
 * www.jcodecraeer.com   
* @version $Id$   
 */
public class Subject extends Observable{   
          
    /**   
     * 业务方法,一旦执行某个操作,则通知观察者   
     */
    public void doBusiness(){   
        if (true) {   
            super.setChanged();   
        }   
        notifyObservers("现在还没有的参数");   
    }   
      
          
    public static void main(String [] args) {   
        //创建一个被观察者   
        Subject subject = new Subject();   
              
        //创建两个观察者   
        Observer mailObserver = new MailObserver();   
        Observer jmsObserver = new JMSObserver();   
              
        //把两个观察者加到被观察者列表中   
        subject.addObserver(mailObserver);   
        subject.addObserver(jmsObserver);   
              
        //执行业务操作   
        subject.doBusiness();   
    }   
}

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

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


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

通过上面的介绍和简单的实例,现在你也可以实现一个自己的观察者了(有时候这个简单的模型并不满足我们的需要,在这种情况下只好自己去写一个类似的但是是为业务定制的observable和observer类了,但显然这中情况并不常见)。事实上spring对观察者模式也有很好的支持(spring可以通过配置文件来执行addobserver方法,这样就可以隐式的把观察者加到被观察者的列表中去了,前提是你的被观察者是spring管理的一个bean之一,详见3楼回复,或者也可以利用afterPropertiesSet方法在被观察者这个bean初始化完成之后立刻把需要的观察者添加进去),除了spring,hibernate中也大量的使用了观察者模式,同时,如果你想再深入一点,可以看看本文第二段给的技术文章的链接。

收藏 赞 (0) 踩 (0)
上一篇:关于Java 23种设计模式的有趣见解
在网络上流畅很广的一篇旧文,暂时没找到原作者,目前所看到的最早转载时间是 2005 年 2 月 28 日。作者用轻松的语言,形象解释了 23 种模式,有很好的启发作用。 创建型模式 1、FACTORY—追MM少不了请吃饭了,麦当劳的鸡翅和肯德基的鸡翅都是MM爱吃的东西,
下一篇:用AOP实现观察者模式
观察者(Observer)模式 用途:定义对象之间的一对多依赖关系,因此,当一个对象的状态发生改变时,其所有依赖项都会得到通知,并自动更新。 它是 OO 设计模式的皇后。该模式被人们广泛应用(特别是在 GUI 应用程序中),并构成了 MVC 架构的关键部分。它处理