设计模式之观察者模式（二）

观察者模式 (有时又被称为发布/订阅模式)是软件设计模式的一种。观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，让他们能够自动更新自己.

观察者模式的组成
        1.抽象主题角色（subjuct）:把所有对观察者对象的引用保存在一个集合中，每个抽象主题角色都可以有任意数量的观察者。抽象主题提供一个接口，可以增加、删除观察者角色、并主题信息发生改变是通知所有的观察者list。一般用一个抽象类或接口来实现
        2.抽象观察者角色（observer）:为所有具体的观察者定义一个接口，在得到主题的通知时更新自己。
        3.具体主题角色(concreteSubjuct):把所有对观察者对象的引用保存在一个集合中，每个抽象主题角色都可以有任意数量的观察者。抽象主题提供一个接口，可以增加和删除观察者角色。一般用一个抽象类或接口来实现。
        4.具体观察者角色(concreteObserver):为所有具体的观察者定义一个接口，在得到主题的通知时更新自己

观察者类图

 

 

 

Java也提供了对观察者模式的内置支持

内置观察者模式主要有2个类，

一个是类Observable（subject）

public class Observable {
    private boolean changed = false;
    private Vector obs;
   

   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);
    }

    /**
     * If this object has changed, as indicated by the 
     * <code>hasChanged</code> method, then notify all of its observers 
     * and then call the <code>clearChanged</code> method to indicate 
     * that this object has no longer changed. 
     * <p>
     * Each observer has its <code>update</code> method called with two
     * arguments: this observable object and the <code>arg</code> argument.
     *
     * @param   arg   any object.
     * @see     java.util.Observable#clearChanged()
     * @see     java.util.Observable#hasChanged()
     * @see     java.util.Observer#update(java.util.Observable, java.lang.Object)
     */
    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);
    }

 一个是接口类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);
}

Observable类是被观察者，子类只要继承它即可。而且添加观察者等方法已经都实现了.
Observer是观察者，只有一个接口方法public void update(Observable arg0, Object arg1)，需要其子类来实现.这里，observable是被观测的对象，而arg是由notifyObservers( )方法传递的值。当被观测对象发生了改变，调update( )方法
1. 被观察者要继承Observable类
2. 被观察者通知观察者时，也就是调用notifyObservers方法时，一定要先调用setChanged()方法(该方法的作用就是将对象里面的changed这个boolean变量设定为true，因为notifyObservers要首先检查该变量是否为true，如果false就不执行而直接返回了)
3. Observable类的两个重载的notifyObservers方法，带参数的那个方法，里面的参数就是Observer接口中的update方法中的第二个参数一个被观测的对象必须服从下面的两个简单规则。第一，如果它被改变了，它必须调用setChanged( )方法。第二，当它准备通知观测程序它的改变时，它必须调用notifyObservers( )方法。这导致了在观测对象中update( )方法的调用。注意——当对象在调用notifyObservers( )方法之前，没有调用setChanged( )方法，就不会有什么动作发生。在update( )被调用之前，被观测对象必须调用setChanged( )和notifyObservers( )两种方法

 

 

应用场景和优缺点

       上面已经对观察者模式做了比较详细的介绍，还是那句话，人无完人，模式也不是万能的，我们要用好设计模式来解决我们的实际问题，就必须熟知模式的应用场景和优缺点：

  观察者模式的应用场景：

1、  对一个对象状态的更新，需要其他对象同步更新，而且其他对象的数量动态可变。

2、  对象仅需要将自己的更新通知给其他对象而不需要知道其他对象的细节。

  观察者模式的优点：

1、  Subject和Observer之间是松偶合的，分别可以各自独立改变。

2、  Subject在发送广播通知的时候，无须指定具体的Observer，Observer可以自己决定是否要订阅Subject的通知。

3、  遵守大部分GRASP原则和常用设计原则，高内聚、低偶合。

观察者模式的缺陷：

1、  松偶合导致代码关系不明显，有时可能难以理解。

2、  如果一个Subject被大量Observer订阅的话，在广播通知的时候可能会有效率问题。