Java之观察者模式

引子

还记得警匪片上，匪徒们是怎么配合实施犯罪的吗？一个团伙在进行行动的时候，总    有一两个人在门口把风——如果有什么风吹草动，则会立即通知里面的同伙紧急撤退。也许放风的人并不一定认识里面的每一个同伙；而在里面也许有新来的小弟不认识这个放风的。但是这没什么，这个影响不了他们之间的通讯，因为他们之间有早已商定好的暗号。

呵呵，上面提到的放风者、偷窃者之间的关系就是观察者模式在现实中的活生生的例子。

 

二、 定义与结构

观察者（Observer）模式又名发布-订阅（Publish/Subscribe）模式。GOF给观察者模式如下定义：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

在这里先讲一下面向对象设计的一个重要原则——单一职责原则。因此系统的每个对象应该将重点放在问题域中的离散抽象上。因此理想的情况下，一个对象只做一件事情。这样在开发中也就带来了诸多的好处：提供了重用性和维护性，也是进行重构的良好的基础。

因此几乎所有的设计模式都是基于这个基本的设计原则来的。观察者模式的起源我觉得应该是在GUI和业务数据的处理上，因为现在绝大多数讲解观察者模式的例子都是这一题材。但是观察者模式的应用决不仅限于此一方面。

下面我们就来看看观察者模式的组成部分。

1)        抽象目标角色（Subject）：目标角色知道它的观察者，可以有任意多个观察者观察同一个目标。并且提供注册和删除观察者对象的接口。目标角色往往由抽象类或者接口来实现。

2)        抽象观察者角色（Observer）：为那些在目标发生改变时需要获得通知的对象定义一个更新接口。抽象观察者角色主要由抽象类或者接口来实现。

3)        具体目标角色（Concrete Subject）：将有关状态存入各个Concrete Observer对象。当它的状态发生改变时, 向它的各个观察者发出通知。

4)        具体观察者角色（Concrete Observer）：存储有关状态，这些状态应与目标的状态保持一致。实现Observer的更新接口以使自身状态与目标的状态保持一致。在本角色内也可以维护一个指向Concrete Subject对象的引用。

放上观察者模式的类图，这样能将关系清晰的表达出来。

 

       可以看得出来，在Subject这个抽象类中，提供了上面提到的功能，而且存在一个通知方法：notify。还可以看出来Subject和ConcreteSubject之间可以说是使用了模板模式（这个模式真是简单普遍到一不小心就用到了）。

       这样当具体目标角色的状态发生改变，按照约定则会去调用通知方法，在这个方法中则会根据目标角色中注册的观察者名单来逐个调用相应的update方法来调整观察者的状态。这样观察者模式就走完了一个流程。

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

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

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

接下来我们看一下附件中的图（请下载附件中的图 http://www.iteye.com/topics/download/eed23def-b8a8-43dc-a753-73d740a3ded0 ），这个图是观察者模式的真实体现，在这个图中有两个类，java.util.Observable，在我们实现观察者模式的时候，我们的被观察者应该继承这个类，这个observable类把持住了被观察者所持有的观察者列表：

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了，是不 是比较像责任链模式了）。

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

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

/**
 * @author 张荣华(ahuaxuan)
* @version $Id$
 */
public class MailObserver implements Observer{

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

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

/**
 * @author 张荣华(ahuaxuan)
 * @version $Id$
 */
public class JMSObserver implements Observer{

	public void update(Observable o, Object arg) {
		System.out.println("发送消息给jms服务器的观察者已经被执行");
	}
}

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

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

/**
 * @author 张荣华(ahuaxuan)
* @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中也大量的使用了观察者模式，同时，如果你想再深入一点，可以看看本文第二段给的ibm 技术文章的链接。

 

转自：http://www.iteye.com/topic/102068/