Java观察者模式在实际项目中如何应用

观察者模式（Observer Pattern）是一种行为设计模式，它定义了对象之间的一对多依赖关系，使得当一个对象改变状态时，所有依赖于它的对象都会得到通知并自动更新。在实际项目中，观察者模式可以应用于多种场景，以下是一些常见的应用实例：

1. 事件监听器

在图形用户界面（GUI）编程中，观察者模式常用于实现事件监听器。例如，在Java Swing中，按钮点击事件就是一个典型的观察者模式应用。

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class ObserverPatternExample {
    public static void main(String[] args) {
        JFrame frame = new JFrame("Observer Pattern Example");
        JButton button = new JButton("Click Me");

        // 创建一个观察者（监听器）
        ActionListener listener = new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("Button clicked!");
            }
        };

        // 将观察者注册到按钮上
        button.addActionListener(listener);

        frame.add(button);
        frame.setSize(300, 200);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
}

2. 订阅/发布系统

在消息传递系统中，观察者模式可以用于实现订阅/发布模式。例如，一个新闻发布系统，读者可以订阅感兴趣的新闻类别，当有新的新闻发布时，系统会通知所有订阅了该类别的读者。

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

interface Observer {
    void update(String message);
}

class NewsPublisher {
    private Map<String, List<Observer>> subscribers = new HashMap<>();

    public void subscribe(String category, Observer observer) {
        subscribers.computeIfAbsent(category, k -> new ArrayList<>()).add(observer);
    }

    public void unsubscribe(String category, Observer observer) {
        List<Observer> obs = subscribers.get(category);
        if (obs != null) {
            obs.remove(observer);
        }
    }

    public void publish(String category, String message) {
        List<Observer> obs = subscribers.get(category);
        if (obs != null) {
            for (Observer o : obs) {
                o.update(message);
            }
        }
    }
}

class Reader implements Observer {
    private String name;

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

    @Override
    public void update(String message) {
        System.out.println(name + " received message: " + message);
    }
}

public class SubscriptionExample {
    public static void main(String[] args) {
        NewsPublisher publisher = new NewsPublisher();

        Reader reader1 = new Reader("Alice");
        Reader reader2 = new Reader("Bob");

        publisher.subscribe("Sports", reader1);
        publisher.subscribe("Sports", reader2);

        publisher.publish("Sports", "Football match won!");

        publisher.unsubscribe("Sports", reader1);

        publisher.publish("Sports", "Basketball match won!");
    }
}

3. 数据绑定

在数据绑定框架中，观察者模式用于实现数据模型和视图之间的同步。当数据模型发生变化时，视图会自动更新。

import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;

class DataModel {
    private String data;
    private PropertyChangeSupport support;

    public DataModel() {
        support = new PropertyChangeSupport(this);
    }

    public void setData(String data) {
        String oldData = this.data;
        this.data = data;
        support.firePropertyChange("data", oldData, data);
    }

    public void addPropertyChangeListener(PropertyChangeListener pcl) {
        support.addPropertyChangeListener(pcl);
    }

    public void removePropertyChangeListener(PropertyChangeListener pcl) {
        support.removePropertyChangeListener(pcl);
    }
}

class DataView implements PropertyChangeListener {
    @Override
    public void propertyChange(PropertyChangeEvent evt) {
        System.out.println("Data changed from " + evt.getOldValue() + " to " + evt.getNewValue());
    }
}

public class DataBindingExample {
    public static void main(String[] args) {
        DataModel model = new DataModel();
        DataView view = new DataView();

        model.addPropertyChangeListener(view);

        model.setData("Initial Data");
        model.setData("Updated Data");
    }
}

4. 状态监控

在监控系统中，观察者模式可以用于实现状态监控。例如，一个温度监控系统，当温度超过某个阈值时，系统会通知所有注册的监控设备。

import java.util.ArrayList;
import java.util.List;

interface TemperatureObserver {
    void update(double temperature);
}

class TemperatureMonitor {
    private List<TemperatureObserver> observers = new ArrayList<>();
    private double temperature;

    public void addObserver(TemperatureObserver observer) {
        observers.add(observer);
    }

    public void removeObserver(TemperatureObserver observer) {
        observers.remove(observer);
    }

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

    private void notifyObservers() {
        for (TemperatureObserver observer : observers) {
            observer.update(temperature);
        }
    }
}

class Heater implements TemperatureObserver {
    @Override
    public void update(double temperature) {
        if (temperature > 30) {
            System.out.println("Heater is turning on!");
        } else {
            System.out.println("Heater is turning off.");
        }
    }
}

public class TemperatureMonitoringExample {
    public static void main(String[] args) {
        TemperatureMonitor monitor = new TemperatureMonitor();
        Heater heater = new Heater();

        monitor.addObserver(heater);

        monitor.setTemperature(25);
        monitor.setTemperature(35);
    }
}

通过这些实际项目中的应用实例，可以看出观察者模式在Java中的广泛应用和灵活性。它能够有效地解耦对象之间的依赖关系，提高系统的可维护性和扩展性。