一文搞懂設計模式—觀察者模式

作者：碼農BookSea 2024-02-18 12:36:09

開發

觀察者模式在許多場景下都非常有用，但在使用時需要注意性能問題、循環依賴和執行順序等方面的考慮。

觀察者模式（Observer Pattern）是一種常見的行為型設計模式，用于在對象之間建立一種一對多的依賴關系。當一個對象的狀態發生變化時，所有依賴它的對象都將得到通知并自動更新。

一、使用場景

觀察者模式在許多應用中都有廣泛的應用，特別是當存在對象之間的一對多關系，并且需要實時通知和更新時，觀察者模式非常適用。下面列舉幾個典型的使用場景：

消息發布/訂閱系統：觀察者模式可以用于構建消息發布/訂閱系統，其中消息發布者充當主題（被觀察者），而訂閱者則充當觀察者。當發布者發布新消息時，所有訂閱者都會收到通知并執行相應操作。
用戶界面組件：在圖形用戶界面 (GUI) 開發中，觀察者模式常被用于處理用戶界面組件之間的交互。當一個組件的狀態發生變化時，其他依賴該組件的組件將自動更新以反映新的狀態。
股票市場監控：在金融領域，觀察者模式可用于實現股票市場監控系統。各個投資者可以作為觀察者訂閱感興趣的股票，在股票價格變動時即時收到通知。
事件驅動系統：觀察者模式也常用于事件驅動系統中，如圖形用戶界面框架、游戲引擎等。當特定事件發生時，觸發相應的回調函數并通知所有注冊的觀察者。

以上僅是觀察者模式的一些典型使用場景，實際上，只要存在對象之間的依賴關系，并且需要實現解耦和靈活性，觀察者模式都可以考慮作為一種設計方案。

二、實現方式

觀察者模式包含以下幾個核心角色：

主題（Subject）：也稱為被觀察者或可觀察者，它是具有狀態的對象，并維護著一個觀察者列表。主題提供了添加、刪除和通知觀察者的方法。
觀察者（Observer）：觀察者是接收主題通知的對象。觀察者需要實現一個更新方法，當收到主題的通知時，調用該方法進行更新操作。
具體主題（Concrete Subject）：具體主題是主題的具體實現類。它維護著觀察者列表，并在狀態發生改變時通知觀察者。
具體觀察者（Concrete Observer）：具體觀察者是觀察者的具體實現類。它實現了更新方法，定義了在收到主題通知時需要執行的具體操作。

下面是觀察者模式的經典實現方式：

(1) 定義觀察者接口：創建一個名為 Observer 的接口，包含一個用于接收通知的方法，例如 update()。

public interface Observer {
    void update();
}

(2) 定義主題接口：創建一個名為 Subject 的接口，包含用于管理觀察者的方法，如 registerObserver()、removeObserver() 和 notifyObservers()。

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

(3) 實現具體主題：創建一個具體類實現 Subject 接口，實現注冊、移除和通知觀察者的方法。在狀態變化時調用 notifyObservers() 方法通知所有觀察者。

import java.util.ArrayList;
import java.util.List;

public class ConcreteSubject implements Subject {
    private final List<Observer> observers = new ArrayList<>();
    private int state;

    public void setState(int state) {
        this.state = state;
        notifyObservers();
    }

    @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();
        }
    }
}

(4) 實現具體觀察者：創建一個具體類實現 Observer 接口，實現接收通知并進行相應處理的方法。

public class ConcreteObserver implements Observer {
    private String name;
    private Subject subject;

    public ConcreteObserver(String name, Subject subject) {
        this.name = name;
        this.subject = subject;
    }

    @Override
    public void update() {
        System.out.println(name+" received notification");
    }
}

(5) 使用觀察者模式：在實際代碼中，我們可以創建具體的主題和觀察者對象，并進行注冊和觸發狀態變化。

public class Main {
    public static void main(String[] args) {
        ConcreteSubject subject = new ConcreteSubject();

        ConcreteObserver observer1 = new ConcreteObserver("Observer 1", subject);
        ConcreteObserver observer2 = new ConcreteObserver("Observer 2", subject);

        subject.registerObserver(observer1);
        subject.registerObserver(observer2);

        subject.setState(10);
        // Output:
        // Observer 1 received notification
        // Observer 2 received notification

        subject.removeObserver(observer1);

        subject.setState(20);
        // Output:
        // Observer 2 received notification
    }
}

1.Java對觀察者模式的支持

觀察者模式在Java語言中的地位非常重要。在JDK的 java.util 包中，提供 Observable 類以及 Observer 接口，它們構成了Java語言對觀察者模式的支持。

使用 Observable 類以及 Observer 接口，優化之后的代碼為：

// 具體觀察者
public class ConcreteObserver implements Observer {
    private String name;

    public ConcreteObserver(String name) {
        // 設置每一個觀察者的名字
        this.name = name;
    }

    /**
     * 當變化之后，就會自動觸發該方法
     */
    @Override
    public void update(Observable o, Object arg) {
        if (arg instanceof Integer) {
            System.out.println(this.name + " 觀察到 state 更改為：" + arg);
        }
    }
}

// 被觀察者，繼承 Observable 表示可以被觀察
public class ConcreteSubject extends Observable {
    private int state;

    public ConcreteSubject(int state) {
        this.setState(state);
    }

    public int getState() {
        return state;
    }

    public void setState(int state) {
        // 設置變化點
        super.setChanged();
        // 狀態變化，通知觀察者
        super.notifyObservers(state);
        this.state = state;
    }

    @Override
    public String toString() {
        return "state：" + this.state;
    }
}

public class TestObserve {
    public static void main(String[] args) {
        // 創建被觀察者
        ConcreteSubject subject = new ConcreteSubject(0);
        // 創建觀察者
        ConcreteObserver ConcreteObserverA = new ConcreteObserver("觀察者 A");
        ConcreteObserver ConcreteObserverB = new ConcreteObserver("觀察者 B");
        ConcreteObserver ConcreteObserverC = new ConcreteObserver("觀察者 C");
        // 添加可觀察對象
        subject.addObserver(ConcreteObserverA);
        subject.addObserver(ConcreteObserverB);
        subject.addObserver(ConcreteObserverC);

        System.out.println(subject);
        // Output:
        // state：0
        subject.setState(1);
        // Output:
        // 觀察者 C 觀察到 state 更改為：1
        // 觀察者 B 觀察到 state 更改為：1
        // 觀察者 A 觀察到 state 更改為：1
        System.out.println(subject);
        // Output:
        // state：1

    }
}

2.Guava對觀察者模式的支持

Guava 中使用 Event Bus 來實現對觀察者模式的支持。

com.google.common.eventbus.EventBus 提供了以下主要方法：

register(Object listener)：將一個對象注冊為事件的監聽器。
unregister(Object listener)：從事件總線中注銷一個監聽器。
post(Object event)：發布一個事件到事件總線，以便通知所有注冊的監聽器。
getSubscribers(Class<?> eventClass)：返回訂閱指定事件類型的所有監聽器的集合。

這些方法提供了事件的注冊、注銷、發布和獲取監聽器等功能，使得開發者可以方便地使用 EventBus 進行事件驅動編程。

@Getter
@AllArgsConstructor
public class MyEvent {
    private String message;
}

@Slf4j
public class EventSubscriber {
    @Subscribe
    public void handleEvent(MyEvent event) {
        String message = event.getMessage();
        // Handle the event logic
        log.info("Received event: " + message);
    }
}

@Test
public void test() {
        EventBus eventBus = new EventBus();
        EventSubscriber subscriber = new EventSubscriber();
        eventBus.register(subscriber);

        // Publish an event
        eventBus.post(new MyEvent("Hello, World!"));
        // Output:
        // Received event: Hello, World!   
    }

3.Spring對觀察者模式的支持

Spring 中可以使用 Spring Event 來實現觀察者模式。

在Spring Event中，有一些核心的概念和組件，包括ApplicationEvent、ApplicationListener、ApplicationContext和ApplicationEventMulticaster。

(1)ApplicationEvent（應用事件）：

ApplicationEvent是Spring Event框架中的基礎類，它是所有事件類的父類。
通過繼承ApplicationEvent，并定義自己的事件類，可以創建特定類型的事件對象。
事件對象通常包含與事件相關的信息，例如狀態變化、操作完成等。

(2) ApplicationListener（應用監聽器）：

ApplicationListener是Spring Event框架中的接口，用于監聽并處理特定類型的事件。
通過實現ApplicationListener接口，并指定感興趣的事件類型，可以創建具體的監聽器。
監聽器可以定義在任何Spring Bean中，當所監聽的事件被發布時，監聽器會自動接收到該事件，并執行相應的處理邏輯。

(3) ApplicationContext（應用上下文）：

ApplicationContext是Spring框架的核心容器，它負責管理Bean的生命周期和依賴關系。
在Spring Event中，ApplicationContext是事件的發布者和訂閱者的容器。
通過獲取ApplicationContext實例，可以獲取ApplicationEventPublisher來發布事件，也可以注冊ApplicationListener來監聽事件。

(4) ApplicationEventMulticaster（事件廣播器）：

ApplicationEventMulticaster是Spring Event框架中的組件，用于將事件廣播給各個監聽器。
它負責管理事件和監聽器之間的關系，并將事件傳遞給對應的監聽器進行處理。
Spring框架提供了幾種實現ApplicationEventMulticaster的類，如SimpleApplicationEventMulticaster和AsyncApplicationEventMulticaster，用于支持不同的事件分發策略。

通過使用這些關鍵概念和組件，可以在 Spring 應用程序中實現事件驅動的編程模型。事件發布者（ApplicationEventPublisher）可以發布特定類型的事件，而訂閱者（ApplicationListener）可以監聽和處理已發布的事件。ApplicationContext作為容器，負責管理事件和監聽器，并使用ApplicationEventMulticaster來實現事件的廣播和分發。

下面是使用 Spring Event 實現觀察者模式的例子：

/**
 * <p>
 * 基礎事件發布類
 * </p>
 *
 */

public abstract class BaseEvent<T> extends ApplicationEvent {

    /**
     * 該類型事件攜帶的信息
     */
    private T eventData;

    /**
     *
     * @param source 最初觸發該事件的對象
     * @param eventData 該類型事件攜帶的信息
     */
    public BaseEvent(Object source, T eventData) {
        super(source);
        this.eventData = eventData;
    }

    public T getEventData() {
        return eventData;
    }
}

這里定義了一個基礎事件發布抽象類，所有的事件發布類都可以繼承此類。

@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public  class User {
    private Integer userId;
    private String userName;
}

public class UserEvent  extends BaseEvent<User>{
    private static final long serialVersionUID = 8145130999696021526L;

    public UserEvent(Object source, User user) {
        super(source,user);
    }

}

@Slf4j
@Service
public class UserListener {
    /*
     * @Async加了就是異步監聽,沒加就是同步（啟動類要開啟@EnableAsync注解）
     * 可以使用@Order定義監聽者順序，默認是按代碼書寫順序
     * 如果返回類型不為void,則會被當成一個新的事件,再次發布
     * @EventListener注解在EventListenerMethodProcessor類被掃描
     * 可以使用SpEL表達式來設置監聽器生效的條件
     * 監聽器可以看做普通方法,如果監聽器拋出異常,在publishEvent里處理即可
     */

    //@Async
    @Order(1)
    @EventListener(condition = "#userEvent.getEventData().getUserName().equals('小明')")
    public String lister1(UserEvent userEvent){
        User user =userEvent.getEventData();
        log.info(user.toString());
        return "小米";
    }

    @Async
    @Order(2)
    @EventListener
    public void lister3(UserEvent userEvent){
        log.info("監聽者2");
    }
    @Async
    @Order(3)
    @EventListener
    public void lister2(String name){
        log.info("我叫："+name);
    }
    
}

@Slf4j
@SpringBootTest
@RunWith(SpringRunner.class)
public class ObserveTest {
    @Resource
    private ApplicationEventPublisher applicationEventPublisher;
    @Test
    public void test() {
        applicationEventPublisher.publishEvent(new UserEvent(this, new User(1, "小明")));
        // Output:
        // User(userId=1, userName=小明)
        // 我叫：小米
        // 監聽者2
    }

}

IDEA 中可以直接跳轉到對應的監聽器。

相比于 Guava Event Bus，Spring Event 在實現觀察者模式時具有以下優點：

集成性：Spring Event 是 Spring 框架的一部分，可以與其他 Spring 組件（如 Spring Boot、Spring MVC 等）無縫集成。這使得在一個應用程序中使用 Spring Event 變得更加方便和統一。
注解驅動：Spring Event 支持使用注解來聲明事件監聽器和發布事件。通過使用 @EventListener 注解，開發人員可以輕松定義事件監聽器方法，并且不需要顯式注冊和注銷監聽器。

三、優缺點

觀察者模式有以下幾個優點：

解耦性：觀察者模式能夠將主題和觀察者之間的耦合度降到最低。主題與觀察者之間都是松散耦合的關系，它們之間可以獨立地進行擴展和修改，而不會相互影響。
靈活性：通過使用觀察者模式，可以動態地添加、刪除和通知觀察者，使系統更加靈活。無需修改主題或觀察者的代碼，就可以實現新的觀察者加入和舊觀察者離開的功能。
一對多關系：觀察者模式支持一對多的依賴關系，一個主題可以有多個觀察者。這樣可以方便地實現消息的傳遞和廣播，當主題狀態更新時，所有觀察者都能得到通知。

雖然觀察者模式具有許多優點，但也存在一些缺點：

可能引起性能問題：如果觀察者較多或通知過于頻繁，可能會導致性能問題。每個觀察者都需要接收通知并執行相應操作，當觀察者較多時，可能會增加處理時間和系統負載。
可能引起循環依賴：由于觀察者之間可以相互注冊，如果設計不當，可能會導致循環依賴的問題。這樣會導致觸發通知的死循環，造成系統崩潰或異常。
順序不確定性：在觀察者模式中，觀察者的執行順序是不確定的。如果觀察者之間有依賴關系，可能會產生意外的結果。

綜上所述，觀察者模式在許多場景下都非常有用，但在使用時需要注意性能問題、循環依賴和執行順序等方面的考慮。

責任編輯：趙寧寧來源： Java隨想錄

觀察者模式設計模式開發