java中如何實現觀察者模式

# Java中如何實現觀察者模式

## 一、觀察者模式概述

觀察者模式（Observer Pattern）是一種行為型設計模式，定義了對象之間的一對多依賴關系。當一個對象（被觀察者/主題）狀態發生改變時，所有依賴它的對象（觀察者）都會自動收到通知并更新。

### 核心角色：
1. **Subject（主題）**：維護觀察者列表，提供注冊/注銷方法
2. **Observer（觀察者）**：定義更新接口
3. **ConcreteSubject（具體主題）**：狀態變化時通知觀察者
4. **ConcreteObserver（具體觀察者）**：實現更新邏輯

## 二、Java內置實現方式

Java在`java.util`包中提供了觀察者模式的簡化實現：

### 1. Observable類（主題基類）

```java
public class Observable {
    private boolean changed = false;
    private Vector<Observer> observers;
    
    public synchronized void addObserver(Observer o) {
        // 添加觀察者
    }
    
    public synchronized void deleteObserver(Observer o) {
        // 移除觀察者
    }
    
    public void notifyObservers(Object arg) {
        // 通知所有觀察者
    }
    
    protected synchronized void setChanged() {
        changed = true;
    }
}

2. Observer接口

public interface Observer {
    void update(Observable o, Object arg);
}

3. 使用示例

// 具體主題
class WeatherStation extends Observable {
    private float temperature;
    
    public void setTemperature(float temp) {
        this.temperature = temp;
        setChanged();  // 標記狀態改變
        notifyObservers(temp);  // 通知觀察者
    }
}

// 具體觀察者
class Display implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("溫度更新: " + arg + "°C");
    }
}

// 使用
public class Main {
    public static void main(String[] args) {
        WeatherStation station = new WeatherStation();
        Display display = new Display();
        
        station.addObserver(display);
        station.setTemperature(25.5f);  // 自動觸發更新
    }
}

三、自定義實現觀察者模式

更靈活的自主實現方式：

1. 定義主題接口

public interface Subject {
    void registerObserver(Observer o);
    void removeObserver(Observer o);
    void notifyObservers();
}

2. 具體主題實現

public class NewsPublisher implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private String latestNews;
    
    @Override
    public void registerObserver(Observer o) {
        observers.add(o);
    }
    
    @Override
    public void removeObserver(Observer o) {
        observers.remove(o);
    }
    
    @Override
    public void notifyObservers() {
        for (Observer o : observers) {
            o.update(latestNews);
        }
    }
    
    public void publishNews(String news) {
        this.latestNews = news;
        notifyObservers();
    }
}

3. 觀察者接口與實現

public interface Observer {
    void update(String message);
}

public class NewsSubscriber implements Observer {
    private String name;
    
    public NewsSubscriber(String name) {
        this.name = name;
    }
    
    @Override
    public void update(String message) {
        System.out.println(name + " 收到新聞: " + message);
    }
}

4. 使用示例

public class Demo {
    public static void main(String[] args) {
        NewsPublisher publisher = new NewsPublisher();
        
        Observer user1 = new NewsSubscriber("張三");
        Observer user2 = new NewsSubscriber("李四");
        
        publisher.registerObserver(user1);
        publisher.registerObserver(user2);
        
        publisher.publishNews("Java 21正式發布！");
    }
}

四、觀察者模式的進階應用

1. 支持多種事件類型

public enum EventType {
    NEWS, WEATHER, STOCK
}

public class Event {
    private EventType type;
    private Object data;
    // 構造方法/getter/setter
}

// 修改Observer接口
public interface Observer {
    void onEvent(Event event);
}

2. 使用Java 8 Lambda簡化

// 直接使用函數式接口
publisher.registerObserver(event -> 
    System.out.println("收到事件: " + event.getType()));

3. 結合Spring框架實現

// 使用ApplicationEvent
@Component
public class CustomEventPublisher {
    @Autowired
    private ApplicationEventPublisher eventPublisher;
    
    public void publish(String message) {
        eventPublisher.publishEvent(new CustomEvent(this, message));
    }
}

// 定義觀察者
@Component
public class EventListener {
    @EventListener
    public void handleEvent(CustomEvent event) {
        // 處理事件
    }
}

五、觀察者模式的最佳實踐

1. 松耦合設計：主題不需要知道觀察者的具體類
2. 事件過濾：可增加事件過濾機制提高效率
3. 線程安全：

   
   // 使用CopyOnWriteArrayList保證線程安全
   private List<Observer> observers = new CopyOnWriteArrayList<>();
   

4. 避免循環依賴：注意觀察者回調時不要反向調用主題

六、與其他模式的對比

七、實際應用場景

1. GUI事件處理（如Java Swing中的ActionListener）
2. 消息通知系統
3. 股票行情更新
4. Spring框架的事件機制
5. 分布式系統中的配置更新

總結

觀察者模式通過解耦觀察者和被觀察者，實現了高效的狀態通知機制。Java中既可以使用內置的Observable類，也可以自定義實現更靈活的方案。在復雜系統中，合理使用觀察者模式能夠顯著降低組件間的耦合度，提高代碼的可維護性和擴展性。 “`

注：本文實際約1500字，可根據需要補充更多代碼示例或應用場景說明以達到1600字要求。