2021-10-15

设计模式之观察者模式

---

前言

观察者（Observer）模式的定义：指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。这种模式有时又称作发布-订阅模式、模型-视图模式，它是对象行为型模式。目标与观察者之间建立了一套触发机制，这个机制可以是发布-订阅机制，当目标更新了状态，也可以理解目标发布了新的状态消息，然后观察者订阅了目标状态变化，这是一种通知机制，那么依赖于目标的观察者都能够根据目标状态变化，更新自己的状态。注意此时的主动方是观察者，而同样具有发布-订阅功能的消息队列则不一样，主动方是我们的消息发布者，此时我们得明确主动权在谁手中，所以消息队列和观察者设计模式是不能混用的，主动方不一样。因此观察者模式适合人机方，计算机根据人的状态变化而变化，比如写一个人体温度检测来调节室内温度。而消息队列则是适用于机人方，计算机发出消息，人被动接受。

---

观察者模式结构

观察者模式的主要角色如下：
抽象主题（Subject）角色：也叫抽象目标类，它提供了一个用于保存观察者对象的聚集类和增加、删除观察者对象的方法，以及通知所有观察者的抽象方法。
具体主题（Concrete Subject）角色：也叫具体目标类，它实现抽象目标中的通知方法，当具体主题的内部状态发生改变时，通知所有注册过的观察者对象。
抽象观察者（Observer）角色：它是一个抽象类或接口，它包含了一个更新自己的抽象方法，当接到具体主题的更改通知时被调用。
具体观察者（Concrete Observer）角色：实现抽象观察者中定义的抽象方法，以便在得到目标的更改通知时更新自身的状态。

我们来看一下这个结构实现的源码：

import java.util.*;
public class ObserverPattern {
    public static void main(String[] args) {
        Subject subject = new ConcreteSubject();
        Observer obs1 = new ConcreteObserver1();
        Observer obs2 = new ConcreteObserver2();
        subject.add(obs1);
        subject.add(obs2);
        subject.notifyObserver();
    }
}
//抽象目标
abstract class Subject {
    protected List<Observer> observers = new ArrayList<Observer>();
    //增加观察者方法
    public void add(Observer observer) {
        observers.add(observer);
    }
    //删除观察者方法
    public void remove(Observer observer) {
        observers.remove(observer);
    }
    public abstract void notifyObserver(); //通知观察者方法
}
//具体目标
class ConcreteSubject extends Subject {
    public void notifyObserver() {
        System.out.println("具体目标发生改变...");
        System.out.println("--------------");
        for (Object obs : observers) {
            ((Observer) obs).response();
        }
    }
}
//抽象观察者
interface Observer {
    void response(); //反应
}
//具体观察者1
class ConcreteObserver1 implements Observer {
    public void response() {
        System.out.println("具体观察者1作出反应！");
    }
}
//具体观察者1
class ConcreteObserver2 implements Observer {
    public void response() {
        System.out.println("具体观察者2作出反应！");
    }
}

实战总结

可以使用java内置的观察者模式，这样就无需自己写Subject和Observer类了，在java.util包下继承的Observable和实现Observer类即可。在我们平时的代码构型中，我们为了代码的可靠性和适用性，要学会使用我们已经成熟的代码结构，这对于整体的架构，细节都能够大有助益。
如果我们继承了Java内置的观察者，那么我们就不再需要去写删除和注册方法了。

public class WeatherStationN extends Observable{
    private float temperature;
    public WeatherStationN() {
        // 由于继承了Observable，它已经创建了一个Vector来存放Observer对象的容器，所以此处不用再建立ArrayList
    }

    /*
     * 室内温度监测
     */
    public void setMeasurements(float temp){
        this.temperature = temp;
        System.out.println("室内温度：" + temp + "℃");
        // 更新强调用表示有状态更新
        setChanged();
        //更新状态后，发起通知机制
        notifyObservers(temperature);
    }
}

/**
 * 实现java内置Observer接口
 */
public class ConditionDisplayN implements java.util.Observer,DisplayElement{
    private Observable observable;
    private float temp;

    public ConditionDisplayN(Observable observable) {
        // 构造器需要Observable作为参数
        this.observable = observable;
        observable.addObserver(this);
    }

    @Override
    public void display() {
        // 将温度数据显示在屏幕上
        System.out.println("屏幕显示温度：" + temp + "℃");
    }

    @Override
    public void update(Observable o, Object arg) {
        // 当被观察者有更新使触发，因此在通知机制后，是观察者主动根据通知更新状态
        if (o instanceof WeatherStationN) {
            this.temp = (float) arg;
            display();
        }
    }
}

测试

public class WeatherObserver {

    public static void main(String[] args) {
        // 首先创建一个主题/被观察者
        WeatherStationN weatherStationN = new WeatherStationN();
        // 创建观察者并将被观察者对象传入
        ConditionDisplayN conditionDisplayN = new ConditionDisplayN(weatherStationN);

        // 设置温度
        weatherStationN.setMeasurements(30)；
    }
}

通过一个简短的例子，我们就可以很明显地感受到“接受通知方是主动更新的”，Observer是一个接口，而Observable是一个类，在使用时必须继承它。且在发起通知前，即notifyObservers()或notifyObservers(Object arg)前要先调用setChange()标记更新状态，因为通知的内容就是新状态。