观察者模式

Define a one-many dependency between objects so that when one object change state, all its dependents are notified and updated automatically.

观察者模式的通用类图

观察者模式的通用源码

• 抽象被观察者

  public abstract class Subject {    //定义一个数组把观察者都放进来    private Vector<Observer> observerVector = new Vector<Observer>();    public void addObserver(Observer observer) {        this.observerVector.add(observer);    }    public void deleteObserver(Observer observer) {        this.observerVector.remove(observer);    }    public void notifyObserver(String context) {        for(Observer observer : observerVector) {            observer.update(context);        }    }}

• 具体被观察者实现类

  public class ConcreteSubject extends Subject {    public void doSomething() {        //自己要处理的逻辑        super.notifyObserver("你好");    }}

• 抽象观察者

  public abstract class Observer {    public void update(String context) {        System.out.println("接受到信息-->" + context);    }}

• 具体观察者实现类

  public class ConcreteObserver extends Observer {    //定义自己逻辑，或者把Observer设置为接口，在实现类中实现}

• 场景类

  public class Client {    public static void main(String[] args) {        ConcreteObserver concreteObserver = new ConcreteObserver();        ConcreteSubject concreteSubject = new ConcreteSubject();        concreteSubject.addObserver(concreteObserver);        concreteSubject.doSomething();    }}

观察者模式的优点

• 观察者和被观察者之间是抽象耦合。不管是增加观察者还是被观察者都非常容易扩展，而且在java中都已经实现了抽象层级的定义。
• 建立一套触发机制。

观察者模式的缺点

• 开发效率和运行效率上，一个被观察者多个观察者，在java机制中是默认是按顺序执行，以个观察者出现问题，会导致后面的观察者卡住，则要考虑使用异步方式。

观察者模式的使用场景

• 关联行为关系，指的是可拆分的，不是组合关系的。
• 事件多级触发场景。
• 跨系统的的信息交换场景，如信息队列的处理机制。

注：
- 广播链的问题，就是出先卡壳问题。
- 异步处理问题。

观察者模式的简单应用的类图及源码

• 韩非子接口（被观察者自身的活动）

  public interface IHanFeiZi {    public void haveBreakfast();    public void haveFun();}

• 被观察者接口

  public interface Observable {    public void addObserver(Observer observer);    public void deleteObserver(Observer observer);    public void notifyObserver(String context);}

• 韩非子实现类（被观察者实现类）

  public class HanFeiZi implements IHanFeiZi, Observable {    private ArrayList<Observer> observerList = new ArrayList<Observer>();    @Override    public void haveBreakfast() {        String breakfast = "韩非子正在吃饭";        System.out.println(breakfast);        this.notifyObserver(breakfast);    }    @Override    public void haveFun() {        String fun = "韩非子正在玩";        System.out.println(fun);        this.notifyObserver(fun);    }    @Override    public void addObserver(Observer observer) {        this.observerList.add(observer);    }    @Override    public void deleteObserver(Observer observer) {        this.observerList.remove(observer);    }    @Override    public void notifyObserver(String context) {        for(Observer observer : observerList) {            observer.update(context);        }    }}

• 观察者接口

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

• 观察者实现类1

  public class LiSi implements Observer {    @Override    public void update(String context) {        System.out.println("李斯向秦始皇汇报----------");        this.reportContext(context);        System.out.println("李斯汇报完毕-------------");    }    private void reportContext(String reportContext) {        System.out.println(reportContext);    }}

• 观察者实现类2

  public class WangSi implements Observer {    @Override    public void update(String context) {        System.out.println("李斯向秦始皇汇报----------");        this.reportContext(context);        System.out.println("李斯汇报完毕-------------");    }    private void reportContext(String reportContext) {        System.out.println(reportContext);    }}

• 观察者实现类3

  public class LiuSi implements Observer {    @Override    public void update(String context) {        System.out.println("李斯向秦始皇汇报----------");        this.reportContext(context);        System.out.println("李斯汇报完毕-------------");    }    private void reportContext(String reportContext) {        System.out.println(reportContext);    }}

• 场景类

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

注:在Java中提供了java.util.Observable实现类和java.util.Observer接口，用于被观察者的抽象类和观察者接口，其中java.util.Observable提供了addObserver()、deleteObserver()、setChanged()、notifyObservers()方法；java.util.Observer提供了update()方法。

其使用java.util.Observable实现类和java.util.Observer接口的类图及上述部分需要改动的源码

• 优化后的被观察者
  public class HanFeiZi extends Observable implements IHanFeiZi {

      @Override    public void haveBreakfast() {        System.out.println("韩非子正在吃饭");        super.setChanged();        super.notifyObservers("韩非子在吃饭");    }    @Override    public void haveFun() {        System.out.println("韩非子正在玩");        super.setChanged();        super.notifyObservers("韩非子在玩");    }}