Observer

观察者（Observer）模式是对象的行为型模式，又叫做发表-订阅（Publish/Subscribe）模式、模型-视图（Model/View）模式、源-收听者（Source/Listener）模式或从属者（Dependents）模式。

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

 

Subject：被观察者，它把所有观察者对象引用保存到一个集合中，每个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以添加和删除观察者对象。

Observer：抽象观察者，为所有的具体观察者定义一个接口，得到主题的更新时通知自己。

Observable  JDK源码：

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

Observer JDK源码：

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

Demo：

import java.util.Observable;
import java.util.Observer;

public class JMSObserver implements Observer{

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

import java.util.Observable;
import java.util.Observer;

public class MailObserver implements Observer{

    /**
     * 这个类取名为MailObserver，顾名思义，她是一个用来发送邮件的观察者
     */
    public void update(Observable o, Object arg) {
        if(o instanceof Subject){
            int flag = ((Subject)o).getFlag();
            if(flag == 1){
                System.out.println("我观察的人在" + arg.toString() + " , 发送邮件的观察者已经被执行。");
            }
        }
    }
}

import java.util.Observable;

public class Subject extends Observable{
    
    private int flag;
    
    public int getFlag() {
        return flag;
    }

    public void setFlag(int flag) {
        this.flag = flag;
    }

    /**
     * 业务方法，一旦执行某个操作，则通知观察者
     */
    public void doBusiness(){
        if (true) {
            //必须加上setChanged()，否则不会通知观察者
            super.setChanged();
        }
        notifyObservers("吃饭");
    }

}

    public static void main(String [] args) {
        //创建一个被观察者
        Subject subject = new Subject();
        subject.setFlag(1);
        //创建两个观察者
        Observer mailObserver = new MailObserver();
        Observer jmsObserver = new JMSObserver();
        
        //把两个观察者加到被观察者列表中
        subject.addObserver(mailObserver);
        subject.addObserver(jmsObserver);
        
        //执行业务操作
        subject.doBusiness();
    }

打印结果：

发送消息给jms服务器的观察者已经被执行
我观察的人在吃饭 , 发送邮件的观察者已经被执行。