设计模式--观察者(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