观察者模式

定义

观察者模式是对象的行为模式，又叫发布-订阅(Publish/Subscribe)模式,模型-视图-模式(Model/View)模式，源-监听器(Source/Listener)模式或从属者(dependents)模式。

一个软件系统常常要求在某一个对象的状态发生改变的时候某些其它的对象做出相应的改变，观察者模式是满足这一要求的最重要的一种方案。
根据观察者对象的引用位置，观察者模式分为两种

• 一

  
  
  
  

  这种实现在传统的模式著作和讨论中比较常见

• 二

  
  
  
  

  java提供的观察者模型就属于这种

观察者模式的结构

第一种结构

第一种实现的模式如下

• 抽象主题(Subject)角色
  主题角色把所有对观察者对象的引用保存在一个集合(比如Vector对象)里，每一个主题都可以有任意数量的观察者。抽象主题提供一个接口，可以增加和删除观察者对象，主题角色又叫抽象被观察者角色

  public interface Subject {
      /**
       * 注册一个新的观察者对象
       * @param observer 观察者
       */
      void attach(Observer observer);
      /**
       * 删除该观察者
       * @param observer 要删除的观察者对象
       */
      void detach(Observer observer);
      /**
       * 通知全部已经注册过的观察者
       */
      void notifyObservers();
  }
  

• 抽象观察者(Observer)角色
  为所有具体的观察者定义一个接口，在得到主题的通知时时更新自己，这个接口叫做更新接口

  public interface Observer {
      /**
       * 观察者更新方法
       */
      void update();
  }
  

• 具体主题(ConcreteSubject)角色
  拥有全部的观察者对象集合，在具体主题的内部状态改变时，给所有的观察者发送通知。具体主题角色又叫具体被观察角色

  public class ConcreteSubject implements Subject{
      private Vector observersVector = new Vector();
      public void attach(Observer observer) {
          observersVector.addElement(observer);
      }
      public void detach(Observer observer) {
          observersVector.removeElement(observer);
      }
      public void notifyObservers() {
          Enumeration enumeration = observers();
          while (enumeration.hasMoreElements()){              
              ((Observer)enumeration.nextElement()).update();
          }
      }
      private Enumeration observers(){
          return ((Vector)observersVector.clone()).elements();
      }
  }
  

• 具体观察者(ConcreteObserver)角色
  具体观察者角色实现实现抽象观察者所要求的更新接口

  public class ConcreteObserver  implements Observer{
      public void update() {
          System.out.println("I am notified");
      }
  }
  

• 测试

  public class MySubject extends ConcreteSubject {
      public void change(){
          System.out.println("data change...");
          notifyObservers();
      }
  }
  

  public class ObserverTest {
      Observer observerA;
      Observer observerB;
      MySubject subject;
  
      @Before
      public void before(){
          observerA = new ConcreteObserver();
          observerB = new ConcreteObserver();
          subject = new MySubject();
          subject.attach(observerA);
          subject.attach(observerB);
      }
      @Test
      public void testObserver(){
          subject.change();
      }
  }
  

第二种结构

第二种实现的模式如下

第二中与第一种基本相同

• 抽象主题角色
  subject类可以用抽象类或类实现

  public abstract class Subject {
      private Vector observersVector = new Vector();
  
      public void attach(Observer observer) {
          observersVector.addElement(observer);
      }
  
      public void detach(Observer observer) {
          observersVector.removeElement(observer);
      }
  
      public void notifyObservers() {
          Enumeration enumeration = observers();
          while (enumeration.hasMoreElements()){
              ((Observer)enumeration.nextElement()).update();
          }
      }
      private Enumeration observers(){
          return ((Vector)observersVector.clone()).elements();
      }
  }
  

• 具体主题角色

  public class ConcreteSubject extends Subject {
      private String data;
      public void change(String newData){
          data = newData;
          System.out.println("data change");
          notifyObservers();
      }
  }
  

• 抽象观察者和具体观察者代码与第一种结构完全相同
• 测试

  public class ObserverTest {
      Observer observerA;
      Observer observerB;
      ConcreteSubject subject;
      @Before
      public void before(){
          observerA = new ConcreteObserver();
          observerB = new ConcreteObserver();
          subject = new ConcreteSubject();
          subject.attach(observerA);
          subject.attach(observerB);
      }
      @Test
      public void testObserver(){
          subject.change("test");
      }
  }
  

全部代码

• demo 地址