《Head First 设计模式》：观察者模式

时间 2020-07-04

标签 head 设计模式观察者繁體版

原文原文链接

正文

1、定义

观察者模式定义了对象之间的一对多依赖，这样一来，当一个对象改变状态时，它的全部依赖者都会收到通知并自动更新。ide

要点：函数

观察者模式定义了对象之间一对多的关系。
观察者模式让主题（可观察者）和观察者之间松耦合。
主题对象管理某些数据，当主题内的数据改变时，会以某种形式通知观察者。
观察者能够订阅（注册）主题，以便在主题数据改变时能收到更新。
观察者若是不想收到主题的更新通知，能够随时取消订阅（注册）。

2、实现步骤

一、建立主题父类/接口

主题父类/接口主要提供了注册观察者、移除观察者、通知观察者三个方法。测试

/**
 * 主题
 */
public class Subject {
    
    /**
     * 观察者列表
     */
    private ArrayList<Observer> observers;
    
    public Subject() {
        observers = new ArrayList<>();
    }

    /**
     * 注册观察者
     */
    public void registerObserver(Observer o) {
        observers.add(o);
    }

    /**
     * 移除观察者
     */
    public void removeObserver(Observer o) {
        observers.remove(o);        
    }

    /**
     * 通知全部观察者,并推送数据（也能够不推送数据，而是由观察者过来拉取数据）
     */
    public void notifyObservers(Object data) {
        for (Observer o : observers) {
            o.update(data);
        }
    }
}

二、建立观察者接口

观察者接口主要提供了更新方法，以供主题通知观察者时调用。this

/**
 * 观察者接口
 */
public interface Observer {

    /**
     * 根据主题推送的数据进行更新操做
     */
    public void update(Object data);
}

三、建立具体的主题，并继承主题父类/实现主题接口

/**
 * 主题A
 */
public class SubjectA extends Subject {
    
    /**
     * 主题数据
     */
    private String data;

    public String getData() {
        return data;
    }

    public void setData(String data) {
        this.data = data;
        // 数据发生变化时，通知观察者
        notifyObservers(data);
    }
}

四、建立具体的观察者，并实现观察者接口

经过观察者类的构造函数，注册成为主题的观察者。code

（1）观察者 A

/**
 * 观察者A
 */
public class ObserverImplA implements Observer {

    private Subject subject;
    
    public ObserverImplA(Subject subject) {
        // 保存主题引用，以便后续取消注册
        this.subject = subject;
        // 注册观察者
        subject.registerObserver(this);
    }
    
    @Override
    public void update(Object data) {
        System.out.println("Observer A：" + data.toString());
    }
}

（2）观察者 B

/**
 * 观察者B
 */
public class ObserverImplB implements Observer {

    private Subject subject;
    
    public ObserverImplB(Subject subject) {
        // 保存主题引用，以便后续取消注册
        this.subject = subject;
        // 注册观察者
        subject.registerObserver(this);
    }
    
    @Override
    public void update(Object data) {
        System.out.println("Observer B：" + data.toString());
    }
}

五、使用主题和观察者对象

public class Test {
    
    public static void main(String[] args) {
        // 主题
        SubjectA subject = new SubjectA();
        // 观察者A
        ObserverImplA observerA = new ObserverImplA(subject);
        // 观察者B
        ObserverImplB observerB = new ObserverImplB(subject);
        // 模拟主题数据变化
        subject.setData("I'm Batman!!!");
        subject.setData("Why so serious...");
    }
}

3、举个栗子

一、背景

你的团队刚刚赢得一纸合约，负责创建 Weather-O-Rama 公司的下一代气象站——Internet 气象观测站。server

该气象站创建在 WeatherData 对象上，由 WeatherData 对象负责追踪目前的天气情况（温度、湿度、气压）。而且具备三种布告板，分别显示目前的情况、气象统计以及简单的预报。当 WeatherData 对象得到最新的测量数据时，三种布告板必须实时更新。对象

而且，这是一个可扩展的气象站，Weather-O-Rama 气象站但愿公布一组 API，好让其余开发人员能够写出本身的气象布告板，并插入此应用中。继承

二、实现

（1）建立主题父类

/**
 * 主题
 */
public class Subject {

    /**
     * 观察者列表
     */
    private ArrayList<Observer> observers;
    
    public Subject() {
        observers = new ArrayList<>();
    }
    
    /**
     * 注册观察者
     */
    public void registerObserver(Observer o) {
        observers.add(o);        
    }

    /**
     * 移除观察者
     */
    public void removeObserver(Observer o) {
        observers.remove(o);        
    }

    /**
     * 通知全部观察者，并推送数据
     */
    public void notifyObservers(float temperature, float humidity, float pressure) {
        for (Observer o : observers) {
            o.update(temperature, humidity, pressure);
        }
    }
}

（2）建立观察者接口

/**
 * 观察者接口
 */
public interface Observer {

    /**
     * 更新观测值
     */
    public void update(float temperature, float humidity, float pressure);
}

（3）建立气象数据类，并继承主题父类

/**
 * 气象数据
 */
public class WeatherData extends Subject {
    
    /**
     * 温度
     */
    private float temperature;
    /**
     * 湿度
     */
    private float humidity;
    /**
     * 气压
     */
    private float pressure;
    
    public void measurementsChanged() {
        // 观测值变化时，通知全部观察者
        notifyObservers(temperature, humidity, pressure);
    }
    
    /**
     * 设置观测值（模拟观测值变化）
     */
    public void setMeasurements(float temperature, float humidity, float pressure) {
        this.temperature = temperature;
        this.humidity = humidity;
        this.pressure = pressure;
        measurementsChanged();
    }
}

（4）建立布告板，并实现观察者接口

/**
 * 目前状态布告板
 */
public class CurrentConditionsDisplay implements Observer {
    
    private Subject weatherData;
    private float temperature;
    private float humidity;
    
    public CurrentConditionsDisplay(Subject weatherData) {
        this.weatherData = weatherData;
        // 注册观察者
        weatherData.registerObserver(this);
    }

    @Override
    public void update(float temperature, float humidity, float pressure) {
        this.temperature = temperature;
        this.humidity = humidity;
        display();
    }
    
    public void display() {
        System.out.println("Current conditions：" + temperature + "F degress and " + humidity + "% humidity");
    }
}

/**
 * 统计布告板
 */
public class StatisticsDisplay implements Observer {

    private Subject weatherData;
    private ArrayList<Float> historyTemperatures;
    
    public StatisticsDisplay(Subject weatherData) {
        this.weatherData = weatherData;
        // 注册观察者
        weatherData.registerObserver(this);
        historyTemperatures = new ArrayList<>();
    }

    @Override
    public void update(float temperature, float humidity, float pressure) {
        this.historyTemperatures.add(temperature);
        display();
    }
    
    public void display() {
        if (historyTemperatures.isEmpty()) {
            return;
        }
        Collections.sort(historyTemperatures);
        float avgTemperature = 0;
        float maxTemperature = historyTemperatures.get(historyTemperatures.size() - 1);
        float minTemperature = historyTemperatures.get(0);
        float totalTemperature = 0;
        for (Float temperature : historyTemperatures) {
            totalTemperature += temperature;
        }
        avgTemperature = totalTemperature / historyTemperatures.size();
        System.out.println("Avg/Max/Min temperature：" + avgTemperature + "/" + maxTemperature + "/" + minTemperature);
    }
}

/**
 * 预测布告板
 */
public class ForecastDisplay implements Observer {

    private Subject weatherData;
    private float temperature;
    private float humidity;
    private float pressure;
    
    public ForecastDisplay(Subject weatherData) {
        this.weatherData = weatherData;
        // 注册观察者
        weatherData.registerObserver(this);
    }

    @Override
    public void update(float temperature, float humidity, float pressure) {
        this.temperature = temperature;
        this.humidity = humidity;
        this.pressure = pressure;
        display();
    }
    
    public void display() {
        System.out.println("Forecast：waiting for implementation...");
    }
}

（5）测试

public class Test {
    
    public static void main(String[] args) {
        // 气象数据
        WeatherData weatherData = new WeatherData();
        // 目前状态布告板
        CurrentConditionsDisplay currentConditionsDisplay = new CurrentConditionsDisplay(weatherData);
        // 统计布告板
        StatisticsDisplay statisticsDisplay = new StatisticsDisplay(weatherData);
        // 预测布告板
        ForecastDisplay forecastDisplay = new ForecastDisplay(weatherData);
        
        // 模拟气象观测值变化
        weatherData.setMeasurements(80, 65, 30.4F);
        weatherData.setMeasurements(82, 70, 29.2F);
        weatherData.setMeasurements(78, 90, 29.2F);
    }
}