Spring Boot观察者模式实战

时间：2024-11-04 06:58:47

观察者模式简介

观察者模式（Observer Pattern）是一种行为设计模式，它定义了对象间的一种一对多的依赖关系，当一个对象状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。这种模式也被称为发布-订阅模式、模型-视图模式、源-监听器模式、从属者模式等。

观察者模式的优缺点

优点

  1. 降低耦合度：观察者模式将主题和观察者分离，主题不需要知道观察者的具体细节，从而降低了它们之间的耦合度。

  2. 支持广播通信：主题状态变化时，可以通知多个观察者，实现了一对多的通信，方便信息广播。

  3. 开闭原则：通过增加新的观察者类和主题类，可以扩展观察者模式，符合开闭原则。

  4. 可维护性：因为观察者和主题之间的关系是松散的，所以更容易维护和修改。

缺点

  1. 性能问题：如果观察者太多，通知所有观察者可能会影响性能，尤其是在大规模系统中。

  2. 顺序问题：观察者的通知顺序可能不确定，如果有顺序要求，需要额外处理。

  3. 可能导致循环依赖：主题和观察者之间的循环依赖可能引入问题，需要小心处理。

实战业务场景

场景一：股票市场监控

假设我们需要开发一个股票市场监控系统，当股票价格发生变化时，系统需要通知所有注册的投资者。这里可以使用观察者模式，将股票市场作为主题，投资者作为观察者。

 

java
 

public interface Observer {
    void update(double price);
}

public interface Subject {
    void registerObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}

public class StockMarket implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private double price;

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

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

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

    public void setPrice(double price) {
        this.price = price;
        notifyObservers();
    }
}

public class Investor implements Observer {
    private String name;

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

    @Override
    public void update(double price) {
        System.out.println(name + " 收到股票价格更新，当前价格为 " + price);
    }
}
 

场景二：天气信息更新
 

另一个场景是天气信息更新系统，当天气数据（如温度、湿度、压力）发生变化时，需要更新所有注册的显示设备。这里，天气数据作为主题，显示设备作为观察者。
 

 

java
 

public class WeatherData {
    private List<Observer> observers;
    private float temperature;
    private float humidity;
    private float pressure;

    public WeatherData() {
        observers = new ArrayList<>();
    }

    public void registerObserver(Observer o) {
        observers.add(o);
    }

    public void removeObserver(Observer o) {
        observers.remove(o);
    }

    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(temperature, humidity, pressure);
        }
    }

    public void measurementsChanged() {
        notifyObservers();
    }

    public void setMeasurements(float temperature, float humidity, float pressure) {
        this.temperature = temperature;
        this.humidity = humidity;
        this.pressure = pressure;
        measurementsChanged();
    }
}

public class DisplayElement implements Observer {
    private float temperature;
    private float humidity;
    private float pressure;

    @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("Current conditions: " + temperature + "F degrees and " + humidity + "% humidity and " + pressure + " mm pressure");
    }
}
 

总结
 

观察者模式在许多场景下都非常有用，特别是在需要实现对象间松耦合通信的情况下。但在使用时需要注意性能问题、循环依赖和执行顺序等方面的考虑。通过上述实战业务场景，我们可以看到观察者模式如何在实际项目中应用，以及如何通过Spring Boot的事件驱动机制来实现观察者模式，提高系统的灵活性和可维护性。
相关文章