本文目录导读：
在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());
}
}
选择哪种方式取决于你的具体需求和项目架构。
