设计模式--观察者(Observer)

GOF给出的定义：

Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.

定义了对象之间的一种一对多的依赖关系，这样，当一个对象的状态发生变化时，所有的依赖对象都被通知并自动更新。

包含观察者与被观察者(也称为主题)

使用场景：

1、有两个抽象类型相互依赖。将他们封装在各自的对象中，就可以对它们单独进行改变和复用。

2、对一个对象的改变需要同时改变其他对象，而不知道具体有多少对象有待改变。

3、一个对象必须通知其他对象，而它又不需知道其他对象是什么。

观察这模式的结构(UML)

标准实现：

目标/被观察者(Subject) 在这里对观察者进行添加和删除操作，并通知观察者

/**
 * 被观察者对象(目标/主题对象)，注册和删除观察者的接口
 * 
 * @author blacksonny
 * @since 2015年7月1日
 */
public class Subject {

    //保存注册的观察者对象
    private List<Observer> observers = new ArrayList<Observer>();
    
    //Attach observer
    public void attach(Observer o){
        observers.add(o);
    }
    
    //Delete observer
    public void detach(Observer o){
        observers.remove(o);
    }
    
    //Notify all observer who has register
    protected void notifyObservers(){
        for (Observer observer : observers) {
            observer.update(this);
        }
    }
}

观察者(Observer)  单目标对象发生变化时，通知这个对象

/**
 * 观察者抽象接口，当目标对象发生改变时，通知这个对象
 * 
 * @author blacksonny
 * @since 2015年7月1日
 */
public interface Observer {

    /**
     * 更新观察者
     * 
     * @param subject
     *            被观察者对象，方便获取被观察者状态
     */
    void update(Subject subject);
}

具体目标对象(ConcreteSubject)  继承Subject,在这里改变自身状态并通知观察者

/**
 * 具体的被观察者对象
 * 
 * @author blacksonny
 * @since 2015年7月1日
 */
public class ConcreteSubject extends Subject {

    // 被观察者对象的状态
    private String subjectState;

    public String getSubjectState() {
        return subjectState;
    }

    public void setSubjectState(String subjectState) {
        this.subjectState = subjectState;
        this.notifyObservers();//状态发生变化，通知观察者
    }

}

观察者实现(ConcreteObserver) 接收被观察者(目标对象)消息，两者状态保持一致

/**
 * 具体的观察者对象，实现更新的方法，使自身的状态和被观察者对象状态保持一致
 * 
 * @author blacksonny
 * @since 2015年7月1日
 */
public class ConcreteObserver implements Observer {
    // 观察者对象状态
    private String observerState;

    @Override
    public void update(Subject subject) {
        observerState = ((ConcreteSubject) subject).getSubjectState();

    }

}

JAVA自身提供的Observer模型

SalaryConreteSubject被观察者实现，继承自JAVA提供的Observable被观察者

观察者模式对消息的通知分为推、拉两种，推模式由subject发起，通知对象可以相对单一；拉模式由observer主动获取。拉模式就需要subject发送自身对象，而推模式可以是一个简单的数据类型，建议采用拉模式，易扩展。

具体到代码中如下的标注的
推方法主动传递一个消息内容 this.notifyObservers(salaryContent); 
拉方法则无需传递参数，默认传递this对象 this.notifyObservers();

/**
 * 继承自jdk的被观察者
 * 
 * @author blacksonny
 * @since 2015年7月1日
 */
public class SalaryConreteSubject extends Observable {

    private String salaryContent;

    public String getSalaryContent() {
        return salaryContent;
    }

    public void setSalaryContent(String salaryContent) {
        this.salaryContent = salaryContent;
        //必须调用
        this.setChanged();
        
        //推模式
        this.notifyObservers(salaryContent);
        
        //拉模式
        this.notifyObservers();
    }
}

Employee具体观察者， 实现Observer接口，并实现update方法，而其中的两个参数，第一个就是拉模式的参数，第二个为退模式参数

/**
 * 实现java.util.Observer
 * 
 * @author blacksonny
 * @since 2015年7月1日
 */
public class Employee implements Observer {

    @Override
    public void update(Observable o, Object arg) {
        System.out.println("本月发放工资情况 拉过来：" + ((SalaryConreteSubject) o).getSalaryContent());
        System.out.println("本月发放工资情况 推过来：" + arg);
    }
}

Client测试：

/**
 * 测试java提供的观察者模式
 * 
 * @author blacksonny
 * @since 2015年7月1日
 */
public class Client {

    /**
     * @param args
     */
    public static void main(String[] args) {

        // 创建被观察者对象
        SalaryConreteSubject subject = new SalaryConreteSubject();

        // 创建观察者对象
        Employee employee = new Employee();
        // 注册对象
        subject.addObserver(employee);

        subject.setSalaryContent("10k");
    }
}

输出结果

本月发放工资情况 拉过来：10k
本月发放工资情况 推过来：10k