设计模式(6)——观察者模式

2018-05-10

设计模式

• 观察者模式

  • 定义对象之间的一对多依赖关系，以便当一个对象更改状态时，将通知其所有依赖关系。
  • 类别：行为模式
  • 组成元素：被观察者类，具体被观察者类，观察者类，具体观察者类
  • 应用场景：如果一个对象的状态发生改变，某些与它相关的对象也要随之做出相应的变化

  被观察者

  import java.util.ArrayList;
  
  abstract class Subject {
      private ArrayList<Observer> observers;
      public Subject() {
  	observers = new ArrayList<>();
      }
      public void attach(Observer observer) {
   	observers.add(observer);
      }
      public void detach(Observer observer) {
  	observers.remove(observer);
      }
      public void notifyObserver(int state) {
  	for(Observer o: observers) {
              o.update(state);
  	}
      }
  }
  
  class ConcreteSubject extends Subject {
      private int subjectState;
      public int getState() {
  	return subjectState;
      }
      public void setState(int newState) {
  	subjectState = newState;
  	System.out.println("subject' state change to " + newState);
  	this.notifyObserver(subjectState);
      }
  }
  

  观察者

  interface Observer {
      public void update(int state);
  }
  
  class ConcreteObserver1 implements Observer {
      public void update(int state) {
  	System.out.println("ConcreteObserver1 know state had changed to " + state);
  	doSomething();
      }	
      private void doSomething() {
  	System.out.println("ConcreteObserver1 do something!!!");
      }
  }
  
  class ConcreteObserver2 implements Observer {
      public void update(int state) {
  	System.out.println("ConcreteObserver2 know state had changed to " + state);
  	doSomething();
      }	
      private void doSomething() {
  	System.out.println("ConcreteObserver2 do something!!!");
      }
  }
  
  class ConcreteObserver3 implements Observer {
      public void update(int state) {
  	System.out.println("ConcreteObserver3 know state had changed to " + state);
  	doSomething();
      }	
      private void doSomething() {
  	System.out.println("ConcreteObserver3 do something!!!");
      }
  }
  

  客户端

  class Client {
      public static void main(String[] args) {
  	ConcreteSubject subject = new ConcreteSubject();	
  	Observer o1 = new ConcreteObserver1();
  	Observer o2 = new ConcreteObserver2();
  	Observer o3 = new ConcreteObserver3();
    		
  	subject.attach(o1);
  	subject.attach(o2);
  	subject.attach(o3);
  
  	subject.setState(11);
  	subject.detach(o2);
  
  	subject.setState(12);
      }
  }
  

  • 适用范围
    • 当一个对象在不知道对方具体是如何实现时需要通知其它对象
    • 当一个对象改变需要通知不确定数的对象时
  • 优点
    • 观察者与被观察者之间是属于轻度的关联关系，并且是抽象耦合的，这样，对于两者来说都比较容易进行扩展。
  • 缺点
    • 观察者模式是一种常用的触发机制，它形成一条触发链，依次对各个观察者的方法进行处理。但同时，这也算是观察者模式一个缺点，由于是链式触发，当观察者比较多的时候，性能问题是比较令人担忧的。并且，在链式结构中，比较容易出现循环引用的错误，造成系统假死。