java设计模式中观察者模式怎么实现

发布时间：2021-11-17 14:45:52 作者：小新
来源：亿速云阅读：188

# Java设计模式中观察者模式怎么实现

## 一、观察者模式概述

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

### 核心角色
1. **Subject（主题/被观察者）**：维护观察者列表，提供注册/注销方法，状态变化时通知观察者
2. **Observer（观察者）**：定义更新接口，接收主题通知
3. **ConcreteSubject（具体主题）**：实现具体业务逻辑，存储观察者感兴趣的状态
4. **ConcreteObserver（具体观察者）**：实现更新逻辑，保持与主题状态一致

## 二、Java实现方式

### 2.1 传统实现（自定义接口）

```java
// 观察者接口
interface Observer {
    void update(String message);
}

// 被观察者抽象类
abstract class Subject {
    private List<Observer> observers = new ArrayList<>();
    
    public void attach(Observer observer) {
        observers.add(observer);
    }
    
    public void detach(Observer observer) {
        observers.remove(observer);
    }
    
    public void notifyObservers(String message) {
        for (Observer observer : observers) {
            observer.update(message);
        }
    }
}

// 具体被观察者
class ConcreteSubject extends Subject {
    private String state;
    
    public void setState(String state) {
        this.state = state;
        notifyObservers(state); // 状态变化时通知观察者
    }
}

// 具体观察者
class ConcreteObserver implements Observer {
    private String name;
    
    public ConcreteObserver(String name) {
        this.name = name;
    }
    
    @Override
    public void update(String message) {
        System.out.println(name + " 收到更新: " + message);
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        ConcreteSubject subject = new ConcreteSubject();
        subject.attach(new ConcreteObserver("观察者A"));
        subject.attach(new ConcreteObserver("观察者B"));
        
        subject.setState("新状态1");
        subject.setState("新状态2");
    }
}

2.2 使用Java内置支持（java.util.Observable）

import java.util.Observable;
import java.util.Observer;

// 被观察者（继承Observable）
class NewsPublisher extends Observable {
    private String news;
    
    public void setNews(String news) {
        this.news = news;
        setChanged();  // 标记状态已改变
        notifyObservers(news);  // 通知观察者
    }
}

// 观察者（实现Observer接口）
class NewsSubscriber implements Observer {
    private String name;
    
    public NewsSubscriber(String name) {
        this.name = name;
    }
    
    @Override
    public void update(Observable o, Object arg) {
        System.out.println(name + " 收到新闻: " + arg);
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        NewsPublisher publisher = new NewsPublisher();
        publisher.addObserver(new NewsSubscriber("订阅者1"));
        publisher.addObserver(new NewsSubscriber("订阅者2"));
        
        publisher.setNews("Java 21发布！");
    }
}

注意：Java 9开始Observable类已被标记为@Deprecated，推荐使用PropertyChangeListener或其他实现方式

2.3 基于事件驱动的实现

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

// 被观察者（使用PropertyChangeSupport）
class WeatherStation {
    private float temperature;
    private final PropertyChangeSupport support = new PropertyChangeSupport(this);
    
    public void addListener(PropertyChangeListener listener) {
        support.addPropertyChangeListener(listener);
    }
    
    public void removeListener(PropertyChangeListener listener) {
        support.removePropertyChangeListener(listener);
    }
    
    public void setTemperature(float newTemp) {
        float oldTemp = this.temperature;
        this.temperature = newTemp;
        support.firePropertyChange("temperature", oldTemp, newTemp);
    }
}

// 观察者（实现PropertyChangeListener）
class WeatherDisplay implements PropertyChangeListener {
    @Override
    public void propertyChange(PropertyChangeEvent evt) {
        System.out.println("温度变化: " + evt.getOldValue() + " -> " + evt.getNewValue());
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        WeatherStation station = new WeatherStation();
        station.addListener(new WeatherDisplay());
        
        station.setTemperature(25.5f);
        station.setTemperature(26.8f);
    }
}

三、观察者模式的应用场景

GUI事件处理：按钮点击、键盘输入等事件监听
发布-订阅系统：消息队列、事件总线
数据监控：股票价格变动、传感器数据采集
MVC架构：模型变更时自动更新视图

四、观察者模式的优缺点

优点

松耦合：观察者和被观察者之间抽象耦合
支持广播通信：一个主题可以对应多个观察者
遵循开闭原则：可以新增观察者而不修改主题

缺点

通知顺序不可控
过度使用可能导致性能问题（大量观察者时）
可能引起循环依赖

五、与其他模式的关系

与中介者模式：都用于减少对象间耦合，但观察者通过订阅机制，中介者通过集中式通信
与责任链模式：观察者所有接收者都会收到通知，责任链可能提前终止传递

六、实际案例：Spring中的观察者模式

Spring框架通过ApplicationEvent和ApplicationListener实现了观察者模式：

// 自定义事件
class OrderEvent extends ApplicationEvent {
    private String orderId;
    
    public OrderEvent(Object source, String orderId) {
        super(source);
        this.orderId = orderId;
    }
    // getter...
}

// 事件监听器
@Component
class OrderEventListener implements ApplicationListener<OrderEvent> {
    @Override
    public void onApplicationEvent(OrderEvent event) {
        System.out.println("处理订单: " + event.getOrderId());
    }
}

// 事件发布
@Service
class OrderService {
    @Autowired
    private ApplicationEventPublisher publisher;
    
    public void createOrder() {
        publisher.publishEvent(new OrderEvent(this, "ORD-123"));
    }
}

七、总结

观察者模式是Java中最常用的设计模式之一，特别适合处理对象间的动态联动关系。根据具体需求可以选择： - 简单场景：自定义接口实现 - 需要更灵活的通知机制：使用PropertyChangeSupport - Spring生态：直接使用ApplicationEvent机制

正确使用观察者模式可以显著提高代码的可维护性和扩展性，但也要注意避免过度使用导致的系统复杂性增加。 “`

（全文约1850字，包含完整代码示例和详细说明）