设计模式——观察者模式

设计模式——观察者模式

很好理解的例子

例子：李斯监控韩非子衣食住行

一个抽象接口：被观察者接口

  public interface Observable{
    public void addObserver(Obeserver observer);
    public void deleteObserver(Observer observer);
    public void notifyObserver(String context);
  }
  //韩非子自己的特定动作
  public interface IHanFeiZi{
    public void haveBreakfast();
    public void haveFun();
  }
  public class HanFeiZi implements IHanFeiZi,Observable {
    // 定义个变长数组，存放所有的观察者
    private ArrayList<Observer> observerList = new ArrayList<Observer>;
    public void addObserver(Obeserver observer){
      this.observerList.add(observer);
    }
    public void deleteObserver(Observer observer){
      this.observerList.remove(observer);
    }
    public void notifyObserver(String context){
      for(Observer observer:observerList){
        observer.update(context);
      }
    }
    public void haveBreakfast(){
      //doSomething
      this.notifyObserver("isHavingBreakfast");
    }
    public void haveFun(){
      // doSomething
      this.notifyObserver("isHavingFun");
    }

  }

一个抽象接口：抽象观察者

  public interface Observer{
    public void update(String context);
  }

  public class Lisi implements Observer{
    public void update(String str){
      // doSomething
      this.reportToQinShiHuang(str);
    }
    private void reportToQinShiHuang(String reportContext){
      System.out.println(reportContext);
    }
  }

场景类

  public class Client(){
    public static void main(String[] args) throws InterruptedExeption{
      Observer liSi = new LiSi();
      Observer wangSi = new WangSi();
      Observer liuSi = new LiuSi();
      // ...一系列Observer
      HanFeiZi hanFeiZi = new HanFeiZi();
      hanFeiZi.addObserver(liSi);
      hanFeiZi.addObserver(wangSi);
      hanFeiZi.addObserver(liuSi);
      hanFeiZi.haveBreakfast();
      HanFeiZi.haveFun();
    }
  }

观察者模式(发布/订阅)总结

定义

Define a one- to- many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.
定义对象间一种一对多的依赖关系使得每当一个对象改变状态，则所有依赖于它的对象都会得到更新

观察者模式

• Subject被观察者

  定义被观察者必须实现的职责，它必须能够动态地增加，取消观察则会。它一般是抽象类或者是实现类，仅仅完成作为被观察者必须实现的职责；管理观察者并通知观察者
  //ArrayList是线程异步，不安全
  //Vector是线程同步，安全
  public abstract class Subject{
    private Vector<Observer> obsVector = new Vector<Observer>();
    public void addObserver(Observer observer){
      this.obsVector.add(observer);
    }
    public void deleteObserver(Observer observer){
      this.obsVector.remove(observer);
    }
    public void notifyObserver(){
      for(Observer observer: this.obsVector ){
        observer.update();
      }
    }
  }

• Observer观察者

   观察者接收到消息后，即进行update操作，对接收到的信息进行处理
  // 观察者一般是一个接口
  public interface Observer{
    public void update();
  }

• ConcreteSubject具体的被观察者

  定义被观察者自己的业务逻辑，同时定义对哪些时间进行通知
  public class ConcreteSubject extends Subject{
    public void doSomething(){
      /**
       * doSomething;
       */
      super.notifyObserver();
    }
  }

• ConcreteObserver具体的观察者

  每个观察在接收到消息后的处理反应是不同，每个观察者都有自己的处理逻辑
  public class ConcreteObserver implements Observer{
    public void update(){
      /**
       * doSomething
       */
    System.out.println("接收消息");
    }
  }

• 场景类

  public class Client{
    public static void main(String[] args) {
      ConcreteSubject subject = new ConcreteSubject();
      Observer observer = new ConcreteObserver();
      //...重复多个Observer观察对象
      subject.addObserver(observer);
      subject.doSomething();
    }
  }

观察者模式的优缺点

观察者模式的优点

• 观察者与被观察者之间是抽象耦合
• 建立一套触发机制

观察者模式的缺点

• 一个观察者卡壳，会影响着整体的执行效率，一般采用异步的方式

观察者模式的适用场景

• 关联行为场景
• 事件多级触发场景
• 跨系统的消息交换场景