17.观察者模式

场景

水果店的青芒果很好吃，但是库存没了，许多顾客都关注青芒何时能到货？

观察者模式

定义

指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

结构

• 抽象主题（Subject）角色：也叫抽象目标类，它提供了一个用于保存观察者对象的聚集类和增加、删除观察者对象的方法，以及通知所有观察者的抽象方法。

• 具体主题（Concrete Subject）角色：也叫具体目标类，它实现抽象目标中的通知方法，当具体主题的内部状态发生改变时，通知所有注册过的观察者对象。

• 抽象观察者（Observer）角色：它是一个抽象类或接口，它包含了一个更新自己的抽象方法，当接到具体主题的更改通知时被调用。

• 具体观察者（Concrete Observer）角色：实现抽象观察者中定义的抽象方法，以便在得到目标的更改通知时更新自身的状态。

UML类图

代码实现

实现

抽象主题

public abstract class Attentions {
    //关注客户列表
    protected List<Observer> observers = new ArrayList();

    //关注顾客
    public void add(Observer observer) {
        observers.add(observer);
    }

    //取消关注
    public void remove(Observer observer) {
        observers.remove(observer);
    }

    //发通知
    public abstract void notifyObservers();
}

具体主题

public class MangoAttention extends Attentions{

    @Override
    public void notifyObservers() {
        //遍历观察者集合，调用每一个顾客的购买方法
        for(Observer obs : observers) {
            obs.update();
        }
    }

    //芒果到货了
    public void perform(){
        this.notifyObservers();
    }
}

抽象观察者

public interface Observer {
    void update();
}

具体观察者

public class CustomerObserver implements Observer {

    private String name;

    public CustomerObserver(String name){
        this.name = name;
    }

    @Override
    public void update() {
        System.out.println(name + "购买青芒");
    }
}

客户端调用

/**
 * 观察者模式
 * 顾客关注了芒果，降价时通知他们
 */
public class TestClient {

    public static void main(String[] args) {
        MongoAttention attentions = new MongoAttention();//目标

        attentions.add(new CustomerObserver("a"));
        attentions.add(new CustomerObserver("b"));
        attentions.add(new CustomerObserver("c"));
        attentions.add(new CustomerObserver("d"));

        //到货
        attentions.perform();
    }
}

结果

a购买青芒
b购买青芒
c购买青芒
d购买青芒

优缺点

优点

• 降低了目标与观察者之间的耦合关系，两者之间是抽象耦合关系。
• 目标与观察者之间建立了一套触发机制。

缺点

• 目标与观察者之间的依赖关系并没有完全解除，而且有可能出现循环引用。
• 当观察者对象很多时，通知的发布会花费很多时间，影响程序的效率。

观察者模式的本质

观察者模式的本质：触发联动

当修改目标对象的状态的时候，就会触发相应的通知，然后会循环调用所有注册的观察者对象的相应方法，其实就相当于联动调用这些观察者方法。

使用场景

• 对象间存在一对多关系，一个对象的状态发生改变会影响其他对象。
• 当一个抽象模型有两个方面，其中一个方面依赖于另一方面时，可将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。

模式的扩展

在 Java 中，通过 java.util.Observable 类和 java.util.Observer 接口定义了观察者模式，只要实现它们的子类就可以编写观察者模式实例。

Observable类

Observable 类是抽象目标类，它有一个 Vector 向量，用于保存所有要通知的观察者对象，下面来介绍它最重要的 3 个方法。

• void addObserver(Observer o) 方法：用于将新的观察者对象添加到向量中。

• void notifyObservers(Object arg) 方法：调用向量中的所有观察者对象的 update方法，通知它们数据发生改变。通常越晚加入向量的观察者越先得到通知。

• void setChange() 方法：用来设置一个 boolean 类型的内部标志位，注明目标对象发生了变化。当它为真时，notifyObservers() 才会通知观察者。

Observer 接口

Observer 接口是抽象观察者，它监视目标对象的变化，当目标对象发生变化时，观察者得到通知，并调用 void update(Observable o,Object arg) 方法，进行相应的工作。

测试代码

具体目标类

public class Mongo extends Observable {
    private String name;

    public Mongo(String name){
        this.name = name;
    }

    //芒果到货了
    public void perform(){
        this.setChanged();
        this.notifyObservers();
    }
}

具体观察类

public class Customer implements Observer {

    private String name;

    public Customer(String name){
        this.name = name;
    }

    @Override
    public void update(Observable o, Object arg) {
        System.out.println(name + "购买青芒");
    }
}

客户端调用

/**
 * 观察者模式
 * 顾客关注了芒果商品，到货时通知他们
 */
public class JdkObserverClient {


    public static void main(String[] args) {
        Mongo attentions = new Mongo("芒果");

        attentions.addObserver(new Customer("a"));
        attentions.addObserver(new Customer("b"));
        attentions.addObserver(new Customer("c"));
        attentions.addObserver(new Customer("d"));

        attentions.perform();
    }
}