设计模式之观察者模式

在学习java AWT或者Swing的时候，我们知道，如果为按钮添加了监听器，那么在我们点击按钮的时候，就可以触发一定的事件。大致过程如下：当点击一个按钮的时候就会产生一个事件，然后检查是否有与该按钮关联的事件处理器（实际上就是一个方法），如果没有，那么什么都不执行；如果有，就会将该事件传递给与该按钮相关联的处理器方法，作为该方法的参数，之后该事件处理器方法就会“自动”得到调用，并且该方法可以使用传递过来的ActionEvent对象进而获得事件发生时与该事件及事件源相关联的那些信息。
其中，“自动调用”是不准确的，确切地说来还是按钮去调用了与之关联的处理器方法。
这其中，也涉及到了一种设计模式————观察者模式

观察者模式：一对多的依赖关系，多个观察者对象同时监听某一主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，让他们能够自动更新自己。

观察者模式的组成：
1.抽象主题角色（也就是被观察者）：把所有观察者对象的引用保存在一个集合中，每个抽象主题角色都可以有任意数量的观察者。抽象主题提供一个接口，可以增加和删除观察者角色。一般用一个抽象类或接口来实现。
2.具体主题角色：在具体主题内部状态改变时，给所有登记过的观察者发出通知。具体主题角色通常用一个子类实现。
3.抽象观察者角色：为所有具体的观察者定义一个接口，在得到主题的通知时更新自己。
4.具体观察者角色：该角色实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态相协调。如果需要，具体观察角色可以保存一个指向具体主题角色的引用。通常用一个子类实现。
实现自己的观察者模式：

/**
 * 主题抽象角色：也称为被观察者
 * addWatcher添加观察者
 * removeWatcher删除观察者
 * notifyWatcher通知观察者状态更新
 */
public interface Watched {
    public void addWatcher(Watcher watcher);
    public void removeWatcher(Watcher watcher);
    public void notifyWatcher(String str);
}

/**
 * 观察者抽象角色
 * update方法用于更新状态，使得观察者状态与主题状态相协调
 */
public interface Watcher {
    public void update(String str);
}

/**
 * 具体主题角色：内部维护了对观察者角色的引用
 * notifyWatcher实质上是通过调用所有观察者的update方法实现了观察者状态的更新
 * 但对于用户来说，好像是主题发出状态改变，观察者“自动”更新状态
 */
public class ConcreateWatched implements Watched {
    private List<Watcher> list = new ArrayList<Watcher>();
    @Override
    public void addWatcher(Watcher watcher) {
        list.add(watcher);
    }

    @Override
    public void removeWatcher(Watcher watcher) {
        list.remove(watcher);
    }

    @Override
    public void notifyWatcher(String str) {
        //遍历所有的观察者引用，调用观察者中的方法
        for(Watcher w : list){
            w.update(str);
        }
    }
}

/**
 *具体观察者角色
 */
public class ConcreateWatcher implements Watcher {
    @Override
    public void update(String str) {
        System.out.println(str);
    }
}

使用示例：

public class Client {
    public static void main(String[] args){
        Watched girl = new ConcreateWatched();

        Watcher boy1 = new ConcreateWatcher();
        Watcher boy2 = new ConcreateWatcher();
        Watcher boy3 = new ConcreateWatcher();

        girl.addWatcher(boy1);
        girl.addWatcher(boy2);
        girl.addWatcher(boy3);

        girl.notifyWatcher("I am so happy.");

        girl.removeWatcher(boy1);
        girl.removeWatcher(boy2);
        girl.notifyWatcher("No happy");
    }
}

观察者模式在Java语言中的地位极其重要，JDK也提供了对观察者模式的内置支持

Observable类：该类用于创建可以观测到你的程序中其他部分的子类。也就是上述所说的主题角色，也是被观察者。当这种子类的对象发生变化时，观测类被通知。观测类必须实现定义了update()方法的Observer接口，也就是观察者角色。当一个观测程序被通知到另一个被观测对象的改变时，update()方法被调用。

一个被观测的对象（主题角色）必须服从下面两个简单的规则：
1.如果它被改变了，必须调用setChanged()
2.当它准备通知观察者它的改变时，必须调用notifyObservers()方法。这会使得在观察者对象中update()方法的调用。
当对象在调用notifyObservers()方法之前，没有调用setChanged()方法，就不会有什么动作发生（查看源码可知原因）。在update()被调用之前，被观测对象必须调用setChanged()和notifyObservers()两种方法

public void notifyObservers(Object arg) {
        /*
         * a temporary array buffer, used as a snapshot of the state of
         * current Observers.
         */
        Object[] arrLocal;

        synchronized (this) {
            /* We don't want the Observer doing callbacks into
             * arbitrary code while holding its own Monitor.
             * The code where we extract each Observable from
             * the Vector and store the state of the Observer
             * needs synchronization, but notifying observers
             * does not (should not).  The worst result of any
             * potential race-condition here is that:
             * 1) a newly-added Observer will miss a
             *   notification in progress
             * 2) a recently unregistered Observer will be
             *   wrongly notified when it doesn't care
             */
            if (!changed)
                return;
            arrLocal = obs.toArray();
            clearChanged();
        }

        for (int i = arrLocal.length-1; i>=0; i--)
            ((Observer)arrLocal[i]).update(this, arg);
    }

如果changed(初始值为false)为false，那么直接返回，不会执行通知操作。所以需要改变changed的状态，则需要setChange()方法，将changed改为true。
应用：编写一个程序，声明一个类，该类继承自Observable(因此该类是个主题角色)，有一个int类型的变量，初始值为10，编写一个for循环，将该数字每次递减1，一直到0为止，每次变化时，都将该数字传递给它的观察者，观测者会打印出该数字；第二个观察者在该数字变为I5之后开始打印该数字。

/**
 * 被观测类（主题角色），需继承Observable
 */
public class MyTheme extends Observable {
    public void count(int num){
        for (;num>=0;num--){
            //使得changed属性为true，从而可以使得主题可以向观察者发送消息
            this.setChanged();
            //每一次技术都调用notifyObservers()
            this.notifyObservers(num);
        }
    }
}

/**
 * 观察者1：打印主题角色的所有计数
 */
public class Watcher1 implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("Watcher1 "+arg);
    }
}

/**
 * 观察者2：打印主题角色的计数，当且仅当技术不大于5
 */
public class Watcher2 implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        if(((Integer)arg).intValue() <= 5){
            System.out.println("Watcher2:"+arg);
        }
    }
}

写个main方法用一下：

public class Client {
    public static void main(String[] args){
        MyTheme theme = new MyTheme();
        Watcher1 obs1 = new Watcher1();
        Watcher2 obs2 = new Watcher2();
        theme.addObserver(obs1);
        theme.addObserver(obs2);
        theme.count(10);
    }
}

输出结果：
Watcher 1:10
Watcher 1:9
Watcher 1:8
Watcher 1:7
Watcher 1:6
Watcher 2:5
Watcher 1:5
Watcher 2:4
Watcher 1:4
Watcher 2:3
Watcher 1:3
Watcher 2:2
Watcher 1:2
Watcher 2:1
Watcher 1:1
Watcher 2:0
Watcher 1:0
从结果可以看出，观察者2只有在计数不大于5时才输出