Java设计模式--观察者模式（Observer）

概述

---

• 观察者模式是使用频率最高的设计模式之一，它用于建立一种对象与对象之间的依赖关系，一个对象发生改变时将自动通知其他对象，其他对象将相应作出反应。在观察者模式中，发生改变的对象称为观察目标，而被通知的对象称为观察者，一个观察目标可以对应多个观察者，而且这些观察者之间可以没有任何相互联系，可以根据需要增加和删除观察者，使得系统更易于扩展。
• 定义：定义对象之间的一种一对多依赖关系，使得每当一个对象状态发生改变时，其相关依赖对象皆得到通知并被自动更新。
• 观察者模式的别名包括发布-订阅（Publish/Subscribe）模式、模型-视图（Model/View）模式、源-监听器（Source/Listener）模式或从属者（Dependents）模式。
• 观察者模式是一种对象行为型模式。
• 学习难度：★★★☆☆
• 使用频率：★★★★★

优缺点

---

• 优点
  • 观察者和具体角色抽象耦合
  • 建立一套触发通知机制
• 缺点

类图

---

组成角色

---

• 抽象目标角色（Subject）
• 具体目标角色（ConcreteSubject）
• 抽象观察者角色（Observer）
• 具体观察者角色（ConcreteObserver）

Code Example

---

抽象目标角色（Subject）

• 目标角色知道它的观察者，可以有任意多个观察者观察同一个目标。

/**
 * 抽象主题角色
 * 
 * @author yanbin
 * 
 */
public abstract class Subject {

   /** 存放所有的观察者 */
   protected List<Observer> observers = new ArrayList<Observer>();

   /**
    * 增加观察者
    * 
    * @param observer
    */
   public void attach(Observer observer) {
      if (null != observer) {
         observers.add(observer);
      }
   }

   /**
    * 移除观察者
    * 
    * @param observer
    */
   public void detach(Observer observer) {
      if (observers.contains(observer)) {
         observers.remove(observer);
      }
   }

   /**
    * 通知所有的观察者，由子类具体实现
    * 
    * @param subjectState
    *            被观察者状态改变
    */
   public abstract void nodifyChange(String subjectState);

}

具体目标角色（ConcreteSubject）

• 将有关状态存入各个ConcreteObserver对象。当它的状态发生改变时,向它的各个观察者发出通知。

/**
 * 具体的主题角色类（被观察者类）
 * 
 * @author yanbin
 * 
 */
public class ConcreteSubject extends Subject {

   /** 主题角色状态 */
   private String subjectState;

   @Override
   public void nodifyChange(String subjectState) {
      this.subjectState = subjectState;
      for (Observer observer : observers) {
         observer.update(subjectState);
      }
   }

   public String getSubjectState() {
      return subjectState;
   }

   public void setSubjectState(String subjectState) {
      this.subjectState = subjectState;
   }

}

抽象观察者角色（Observer）

• 为那些在目标发生改变时需要获得通知的对象定义一个更新接口。

/**
 * 抽象观察者角色，定义统一的更新状态方法
 * 
 * @author yanbin
 * 
 */
public interface Observer {

   /**
    * 状态改变
    * 
    * @param subjectState
    */
   public void update(String subjectState);

}

具体观察者角色（ConcreteObserver）

• 存储有关状态，这些状态应与目标的状态保持一致。

/**
 * 具体观察者角色
 * 
 * @author yanbin
 * 
 */
public class ConcreteObserver implements Observer {

   /** 观察者状态 */
   private String observerState;

   public ConcreteObserver(String observerState) {
      this.observerState = observerState;
   }

   @Override
   public void update(String observerState) {
      this.observerState = observerState;
      System.out.println("接到通知，做出反应。状态改为：" + this.observerState);
   }

   public String getObserverState() {
      return observerState;
   }

   public void setObserverState(String observerState) {
      this.observerState = observerState;
   }

}

客户端

/**
 * 观察者模式：定义了一种一对多的依赖关系，让多个观察者对象监听某一个主题对象。这个主体对象在状态发生变化时，会通知所有观察者对象，使他们能够自动更新自己。<br>
 * 组成：抽象目标角色（Subject）：目标角色知道它的观察者，可以有任意多个观察者观察同一个目标。<br>
 * 抽象观察者角色（Observer）：为那些在目标发生改变时需要获得通知的对象定义一个更新接口。<br>
 * 具体目标角色（ConcreteSubject）：将有关状态存入各个ConcreteObserver对象。当它的状态发生改变时,向它的各个观察者发出通知。<br>
 * 具体观察者角色（ConcreteObserver）：存储有关状态，这些状态应与目标的状态保持一致。<br>
 * 
 * @author yanbin
 * 
 */
public class ObserverPattern {

   public static void main(String[] args) {
      Subject subject = new ConcreteSubject();
      Observer observerA = new ConcreteObserver("A");
      Observer observerB = new ConcreteObserver("B");
      subject.attach(observerA);
      subject.attach(observerB);
      subject.nodifyChange("状态改成C了！ ");
   }

}