Java观察者案例怎么实现监听

本文目录导读：

1. 使用Java内置的Observer/Observable（JDK 9之前）
2. 自定义观察者模式（最常用）
3. 使用事件监听器模式（AWT/Swing风格）
4. 使用Java 8+ 函数式接口（简洁版）
5. 推荐实践方案

在Java中实现观察者模式（监听器模式）主要有以下几种方式,我来详细说明：

使用Java内置的Observer/Observable（JDK 9之前）

import java.util.Observable;
import java.util.Observer;
// 被观察者（主题）
class WeatherData extends Observable {
    private float temperature;
    public void setTemperature(float temperature) {
        this.temperature = temperature;
        // 数据变化，通知观察者
        setChanged();
        notifyObservers(temperature);
    }
}
// 观察者
class CurrentConditionsDisplay implements Observer {
    private String name;
    public CurrentConditionsDisplay(String name) {
        this.name = name;
    }
    @Override
    public void update(Observable o, Object arg) {
        float temperature = (Float) arg;
        System.out.println(name + " 收到温度更新：" + temperature + "°C");
    }
}
// 使用示例
public class ObserverExample {
    public static void main(String[] args) {
        WeatherData weatherData = new WeatherData();
        CurrentConditionsDisplay display1 = new CurrentConditionsDisplay("显示器1");
        CurrentConditionsDisplay display2 = new CurrentConditionsDisplay("显示器2");
        weatherData.addObserver(display1);
        weatherData.addObserver(display2);
        weatherData.setTemperature(25.5f);
        weatherData.setTemperature(28.0f);
    }
}

自定义观察者模式（最常用）

import java.util.ArrayList;
import java.util.List;
// 观察者接口
interface Observer {
    void update(String message);
}
// 被观察者接口
interface Subject {
    void registerObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}
// 具体被观察者
class NewsPublisher implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private String latestNews;
    @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(latestNews);
        }
    }
    // 发布新消息
    public void publishNews(String news) {
        this.latestNews = news;
        System.out.println("发布新闻: " + news);
        notifyObservers();
    }
}
// 具体观察者
class Subscriber implements Observer {
    private String name;
    public Subscriber(String name) {
        this.name = name;
    }
    @Override
    public void update(String message) {
        System.out.println(name + " 收到新闻: " + message);
    }
}
// 使用示例
public class CustomObserverExample {
    public static void main(String[] args) {
        NewsPublisher publisher = new NewsPublisher();
        Subscriber subscriber1 = new Subscriber("张三");
        Subscriber subscriber2 = new Subscriber("李四");
        publisher.registerObserver(subscriber1);
        publisher.registerObserver(subscriber2);
        publisher.publishNews("Java 17 发布!");
        publisher.publishNews("Spring Boot 3.0 来了!");
        publisher.removeObserver(subscriber2);
        publisher.publishNews("只通知张三的新闻");
    }
}

使用事件监听器模式（AWT/Swing风格）

import java.util.EventListener;
import java.util.EventObject;
import java.util.ArrayList;
import java.util.List;
// 事件对象
class DataChangeEvent extends EventObject {
    private String dataType;
    private Object newValue;
    public DataChangeEvent(Object source, String dataType, Object newValue) {
        super(source);
        this.dataType = dataType;
        this.newValue = newValue;
    }
    public String getDataType() {
        return dataType;
    }
    public Object getNewValue() {
        return newValue;
    }
}
// 监听器接口
interface DataChangeListener extends EventListener {
    void onDataChanged(DataChangeEvent event);
}
// 事件源
class DataModel {
    private List<DataChangeListener> listeners = new ArrayList<>();
    private String name;
    private int value;
    public DataModel(String name) {
        this.name = name;
    }
    public void addDataChangeListener(DataChangeListener listener) {
        listeners.add(listener);
    }
    public void removeDataChangeListener(DataChangeListener listener) {
        listeners.remove(listener);
    }
    public void setValue(int value) {
        int oldValue = this.value;
        this.value = value;
        if (oldValue != value) {
            fireDataChanged("value", value);
        }
    }
    private void fireDataChanged(String dataType, Object newValue) {
        DataChangeEvent event = new DataChangeEvent(this, dataType, newValue);
        for (DataChangeListener listener : listeners) {
            listener.onDataChanged(event);
        }
    }
}
// 监听器实现
class DataChangeHandler implements DataChangeListener {
    private String handlerName;
    public DataChangeHandler(String handlerName) {
        this.handlerName = handlerName;
    }
    @Override
    public void onDataChanged(DataChangeEvent event) {
        System.out.println(handlerName + " 处理事件 - 数据: " + 
                         event.getDataType() + " 新值: " + event.getNewValue());
    }
}
// 使用示例
public class EventListenerExample {
    public static void main(String[] args) {
        DataModel model = new DataModel("温度传感器");
        DataChangeHandler handler1 = new DataChangeHandler("处理器1");
        DataChangeHandler handler2 = new DataChangeHandler("处理器2");
        model.addDataChangeListener(handler1);
        model.addDataChangeListener(handler2);
        model.setValue(25);
        model.setValue(30);
    }
}

使用Java 8+ 函数式接口（简洁版）

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
class EventManager<T> {
    private List<Consumer<T>> listeners = new ArrayList<>();
    public void addListener(Consumer<T> listener) {
        listeners.add(listener);
    }
    public void removeListener(Consumer<T> listener) {
        listeners.remove(listener);
    }
    public void fireEvent(T event) {
        listeners.forEach(listener -> listener.accept(event));
    }
}
// 使用示例
public class FunctionalObserverExample {
    public static void main(String[] args) {
        EventManager<String> eventManager = new EventManager<>();
        // 添加监听器（Lambda表达式）
        eventManager.addListener(event -> 
            System.out.println("监听器1 收到: " + event));
        eventManager.addListener(event -> 
            System.out.println("监听器2 收到: " + event + " (处理完成)"));
        // 触发事件
        eventManager.fireEvent("任务完成");
        eventManager.fireEvent("数据更新");
    }
}

推荐实践方案

对于大多数Java应用，推荐使用 方案2（自定义观察者模式）,因为：

• 灵活性高
• 不依赖特定JDK版本
• 易于理解和维护
• 可以自定义事件类型和数据

对于Spring项目，还可以使用@EventListener注解实现声明式事件监听：

@Component
public class UserService {
    @EventListener
    public void handleUserCreated(UserCreatedEvent event) {
        System.out.println("用户创建事件: " + event.getUsername());
    }
}

选择哪种方式取决于你的具体需求和项目架构。