java設計模式中觀察者模式怎么實現

# 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);
    }
}

三、觀察者模式的應用場景

1. GUI事件處理：按鈕點擊、鍵盤輸入等事件監聽
2. 發布-訂閱系統：消息隊列、事件總線
3. 數據監控：股票價格變動、傳感器數據采集
4. MVC架構：模型變更時自動更新視圖

四、觀察者模式的優缺點

優點

• 松耦合：觀察者和被觀察者之間抽象耦合
• 支持廣播通信：一個主題可以對應多個觀察者
• 遵循開閉原則：可以新增觀察者而不修改主題

缺點

• 通知順序不可控
• 過度使用可能導致性能問題（大量觀察者時）
• 可能引起循環依賴

五、與其他模式的關系

1. 與中介者模式：都用于減少對象間耦合，但觀察者通過訂閱機制，中介者通過集中式通信
2. 與責任鏈模式：觀察者所有接收者都會收到通知，責任鏈可能提前終止傳遞

六、實際案例：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字，包含完整代碼示例和詳細說明）