行为型设计模式之观察者模式

后端

2023-12-24 13:26:38

设计模式的精髓在于，封装变化，隔离可变性。

设计模式主要解决的问题包括：创建型设计模式解决“对象的创建”问题，创建和使用代码解耦；结构型设计模式解决“类或对象的组合或组装”问题，将不同功能代码解耦；行为型设计模式则主要解决“对象的交互”问题，让对象之间可以相互通信和协调。

行为型设计模式有很多种，其中观察者模式是一种非常常见且实用的设计模式。观察者模式的核心思想是：当一个对象发生改变时，所有依赖它的对象都会收到通知并自动更新。这种模式可以帮助我们构建松耦合、易于扩展的系统。

观察者模式的结构

观察者模式主要由以下几个角色组成：

被观察者（Subject） ：被观察者是发生变化的对象，它负责通知所有观察者对象。
观察者（Observer） ：观察者是依赖于被观察者的对象，它负责接收被观察者发出的通知并做出相应的处理。
具体被观察者（ConcreteSubject） ：具体被观察者是实现了被观察者接口的具体类，它负责将自己的状态变化通知给所有观察者对象。
具体观察者（ConcreteObserver） ：具体观察者是实现了观察者接口的具体类，它负责接收具体被观察者的通知并做出相应的处理。

观察者模式的优点

观察者模式有很多优点，包括：

松耦合 ：观察者模式可以帮助我们构建松耦合的系统。被观察者和观察者对象之间是通过接口进行交互的，因此它们之间不需要知道对方的具体实现细节。这使得系统更加灵活和易于维护。
可扩展性 ：观察者模式很容易扩展。我们可以随时添加新的观察者对象，而不需要修改被观察者的代码。这使得系统很容易适应新的需求。
可重用性 ：观察者模式可以被重用于不同的系统中。这使得我们可以在不同的项目中重复利用相同的代码，从而提高开发效率。

观察者模式的应用场景

观察者模式可以用于多种场景，包括：

事件驱动系统 ：在事件驱动系统中，当一个事件发生时，系统会通知所有订阅该事件的观察者对象。观察者对象可以根据事件类型做出相应的处理。
消息传递系统 ：在消息传递系统中，当一条消息到达时，系统会通知所有订阅该消息的观察者对象。观察者对象可以根据消息内容做出相应的处理。
GUI系统 ：在GUI系统中，当用户操作某个控件时，系统会通知所有订阅该控件的观察者对象。观察者对象可以根据控件的操作做出相应的处理。

观察者模式的示例

为了更好地理解观察者模式，我们来看一个简单的示例。假设我们有一个温度传感器，它可以测量室温并将其显示在屏幕上。当室温发生变化时，温度传感器会通知所有订阅它的观察者对象。

// 被观察者接口
interface TemperatureSensor {

    void addObserver(Observer observer);

    void removeObserver(Observer observer);

    void notifyObservers();

    double getTemperature();
}

// 具体被观察者类
class ConcreteTemperatureSensor implements TemperatureSensor {

    private List<Observer> observers = new ArrayList<>();

    private double temperature;

    @Override
    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(this);
        }
    }

    @Override
    public double getTemperature() {
        return temperature;
    }

    public void setTemperature(double temperature) {
        this.temperature = temperature;
        notifyObservers();
    }
}

// 观察者接口
interface Observer {

    void update(TemperatureSensor temperatureSensor);
}

// 具体观察者类
class ConcreteObserverA implements Observer {

    @Override
    public void update(TemperatureSensor temperatureSensor) {
        System.out.println("Current temperature: " + temperatureSensor.getTemperature());
    }
}

// 具体观察者类
class ConcreteObserverB implements Observer {

    @Override
    public void update(TemperatureSensor temperatureSensor) {
        System.out.println("Temperature change: " + (temperatureSensor.getTemperature() - temperatureSensor.getTemperature()));
    }
}

// 测试
public class Main {

    public static void main(String[] args) {
        TemperatureSensor temperatureSensor = new ConcreteTemperatureSensor();

        Observer observerA = new ConcreteObserverA();
        Observer observerB = new ConcreteObserverB();

        temperatureSensor.addObserver(observerA);
        temperatureSensor.addObserver(observerB);

        temperatureSensor.setTemperature(20.0);
        temperatureSensor.setTemperature(25.0);
        temperatureSensor.setTemperature(30.0);
    }
}