源码分析Java的观察者模式

java中的观察者模式，简而言之就是多个对对象对一个对象的观察，当被观察者改变时，会通知观察者。Java为这种模式，特地的提供Observable类和Observer接口实现这种模式，先看下面的代码实现观察者模式

被观察者类

class Sub extends Observable{
    private String msg;
    public String getmsg(){
        return msg;
    }
    public void setmsg(String msg){
        this.msg=msg;
        setChanged();
        notifyObservers();
    }
}
class Sub1 extends Observable{
     private String msg;
    public String getmsg(){
        return msg;
        }
    public void setmsg(String msg){
        this.msg=msg;
        setChanged();
        notifyObservers();
    }
}

观察者

class obser implements Observer{
         public void registerObject(Observable o){
         o.addObserver(this);
         }
        public void update(Observable arg0, Object arg1) {
            // TODO Auto-generated method stub
            if(arg0 instanceof Sub){
                Sub oo=(Sub)arg0;
            System.out.println("接受到Sub改变"+oo.getmsg());
                                }
            if(arg0 instanceof Sub1){
                Sub1 oo=(Sub1)arg0;
            System.out.println("接受到Sub1改变"+oo.getmsg());
                    }
    }

主程序

public class test {

    /**
     * @param args
     */

    public static void main(String[] args) {
        // TODO Auto-generated method stub
          Sub s1=new Sub();
          Sub1 s2 = new Sub1();
          obser o1=new obser();
          obser 02=new obser();
          obser o3=new obser();
          o1.registerObject(s1);
          o2.registerObject(s2);
          o3.registerObject(s1);
          s1.setmsg("aaa");
          s2.setmsg("bbb");
    }

}

解释一下代码，最前面定义两个被观察者，后面定义一个观察者类，在主函数里面,两个观察者对s1,一个对s2,当被观察的对象，信息发生改变是就就会通知观察者，这个程序运行结果为：

符合我们的预期，现在分析一下这段代码

public void setmsg(String msg){
        this.msg=msg;
        setChanged();
        notifyObservers();
    }

我们是通过调用被观察者的setmsg触发，通知观察者，setChanged()和notifyObservers(),来看一下这段代码,直接贴Observable源码

package java.util;
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);
    }
public synchronized void deleteObservers() {
        obs.removeAllElements();
    }
protected synchronized void setChanged() {
        changed = true;
    }
protected synchronized void clearChanged() {
        changed = false;
    }
public synchronized boolean hasChanged() {
        return changed;
    }
   public synchronized int countObservers() {
        return obs.size();
    }
} 

Oberverable这个类，里面定义一个Vector容器来装载自己的观察者，然后notifyObservers()这个函数，就会每一个调用每一个观察者的update()函数，实现通知的效果。然后你可以在复写Observer这个接口的实现通过采用instanceof来判断属于哪一个类，实现具体的操作。