观察者模式（一文讲透）

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战(已更新的所有项目都能学习) / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

• 新开坑项目:《Spring AI 项目实战》 正在持续爆肝中，基于 Spring AI + Spring Boot 3.x + JDK 21...， 点击查看 ;
• 《从零手撸：仿小红书（微服务架构）》 已完结，基于 Spring Cloud Alibaba + Spring Boot 3.x + JDK 17...，点击查看项目介绍 ;演示链接： http://116.62.199.48:7070 ;
• 《从零手撸：前后端分离博客项目（全栈开发）》 2 期已完结，演示链接： http://116.62.199.48/ ;

截止目前， 星球 内专栏累计输出 90w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 3100+ 小伙伴加入学习 ，欢迎点击围观

前言

在软件开发中，系统模块之间的耦合度往往是影响代码可维护性和扩展性的关键因素。观察者模式（Observer Pattern）作为设计模式中的一员，通过定义一种一对多的依赖关系，使得多个观察者对象能够实时感知到被观察对象（主题）的状态变化。这种模式不仅简化了系统组件间的交互，还为动态添加或移除观察者提供了灵活的解决方案。本文将从基础概念、实现方法、实际案例等角度，深入浅出地解析观察者模式的原理与应用。

核心概念与定义

观察者模式的核心在于建立“主题”与“观察者”之间的订阅-发布机制。其核心组成部分包括：

• 主题（Subject）：被观察的对象，负责维护观察者列表，并在自身状态发生变化时主动通知所有已注册的观察者。
• 观察者（Observer）：接收通知的对象，需要实现特定接口以定义如何处理接收到的信息。
• 注册与注销机制：观察者可通过接口方法动态添加或移出主题的观察者列表。
• 通知机制：当主题状态改变时，主动调用所有观察者的更新方法，传递必要的数据。

形象比喻：
想象一个学校场景，老师（主题）在课堂上讲解知识点，学生（观察者）通过订阅课程来接收信息。当老师更新教学内容时，所有订阅的学生都能自动收到通知并更新笔记。这个过程中，老师无需关心学生如何处理信息，学生也无需知道其他同学的存在，双方仅通过订阅关系保持松耦合。

观察者模式的实现步骤

以下是实现观察者模式的基本流程：

1. 定义观察者接口

观察者接口需包含一个用于更新的抽象方法，例如 update()。

// Java 示例：定义 Observer 接口
public interface Observer {
    void update(String message);
}

2. 创建主题类

主题类需维护观察者列表，并提供注册、移除观察者及通知方法：

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

public class WeatherStation implements Subject {
    private List<Observer> observers;
    private String weatherData;

    public WeatherStation() {
        observers = new ArrayList<>();
    }

    @Override
    public void registerObserver(Observer o) {
        observers.add(o);
    }

    @Override
    public void removeObserver(Observer o) {
        observers.remove(o);
    }

    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(weatherData);
        }
    }

    public void setWeatherData(String data) {
        this.weatherData = data;
        notifyObservers(); // 状态变化后主动通知
    }
}

3. 实现具体观察者

每个观察者需实现接口中的 update() 方法，定义如何处理主题传递的数据：

public class PhoneApp implements Observer {
    @Override
    public void update(String message) {
        System.out.println("手机应用收到天气更新：" + message);
    }
}

public class WebPage implements Observer {
    @Override
    public void update(String message) {
        System.out.println("网页端显示新天气：" + message);
    }
}

4. 运行流程

• 观察者通过 registerObserver() 方法订阅主题；
• 主题状态变化时调用 notifyObservers()，触发所有观察者的 update() 方法；
• 观察者根据自身逻辑处理接收到的数据。

观察者模式的实际案例与代码示例

以下通过具体场景进一步说明模式的应用：

案例1：天气监测系统

假设需要构建一个天气监测站，当天气数据更新时，多个客户端（如手机应用、网页、邮件服务）需同步接收信息。

完整代码示例（Java）：

// 主题接口
public interface Subject {
    void registerObserver(Observer o);
    void removeObserver(Observer o);
    void notifyObservers();
}

// 具体主题：天气站
public class WeatherStation implements Subject {
    // 前面已实现的代码（略）
}

// 具体观察者：邮件服务
public class EmailService implements Observer {
    @Override
    public void update(String message) {
        System.out.println("发送邮件：天气变化通知 - " + message);
    }
}

// 客户端调用
public class WeatherClient {
    public static void main(String[] args) {
        WeatherStation station = new WeatherStation();
        station.registerObserver(new PhoneApp());
        station.registerObserver(new WebPage());
        station.registerObserver(new EmailService());

        station.setWeatherData("晴，温度25℃");
    }
}

运行结果：

手机应用收到天气更新：晴，温度25℃
网页端显示新天气：晴，温度25℃
发送邮件：天气变化通知 - 晴，温度25℃

案例2：UI 事件监听

在图形化界面开发中，按钮点击事件的监听机制本质上也是观察者模式的应用。例如，按钮（主题）被点击时，所有注册的监听器（观察者）都会触发对应的回调函数。

Python 示例（简化版）：

class Button:
    def __init__(self):
        self.observers = []

    def add_observer(self, observer):
        self.observers.append(observer)

    def notify(self):
        for observer in self.observers:
            observer.update()

class ConsoleLogger:
    def update(self):
        print("按钮被点击！日志记录中...")

class DatabaseRecorder:
    def update(self):
        print("按钮被点击！数据库记录已更新")

button = Button()
button.add_observer(ConsoleLogger())
button.add_observer(DatabaseRecorder())
button.notify()  # 触发所有观察者的 update 方法

观察者模式的优缺点分析

优点

缺点

进阶应用与模式变体

1. 松耦合的事件总线

在大型系统中，可引入“事件总线”作为中心主题，将发布-订阅机制解耦到更高层次。例如：

public class EventBus {
    private static final EventBus INSTANCE = new EventBus();
    private final Map<String, List<Observer>> eventMap = new HashMap<>();

    public static EventBus getInstance() {
        return INSTANCE;
    }

    public void subscribe(String eventType, Observer observer) {
        eventMap.computeIfAbsent(eventType, k -> new ArrayList<>()).add(observer);
    }

    public void publish(String eventType, String data) {
        List<Observer> observers = eventMap.get(eventType);
        if (observers != null) {
            observers.forEach(o -> o.update(data));
        }
    }
}

2. 反向观察者模式（Inverse Observer）

在某些场景下，观察者需要主动通知主题，例如用户输入验证。此时可通过回调接口实现双向通信：

public interface Validator {
    void onInputValidated(boolean isValid);
}

public class InputField {
    private Validator validator;

    public void setValidator(Validator v) {
        this.validator = v;
    }

    public void onTextChange(String text) {
        boolean isValid = !text.isEmpty();
        if (validator != null) {
            validator.onInputValidated(isValid);
        }
    }
}

总结与实践建议

观察者模式通过“主题-观察者”的订阅机制，有效降低了系统组件间的耦合度，是构建可扩展、易维护系统的利器。其核心思想在于：

1. 关注点分离：主题专注于状态管理，观察者专注于响应逻辑；
2. 动态可变性：允许在运行时灵活调整观察者集合；
3. 事件驱动架构：天然适配异步、实时性要求高的场景。

在实际开发中，可结合以下策略提升应用效果：

• 事件过滤：为观察者添加过滤条件，减少不必要的通知；
• 异步通知：通过线程池或消息队列实现异步处理，避免阻塞主线程；
• 版本化设计：在复杂系统中为事件定义版本号，确保兼容性。

掌握观察者模式不仅能够解决具体的技术问题，更能培养面向对象设计的思维模式。建议读者通过重构现有代码或实现一个小型消息通知系统，亲身体验该模式的优势与局限性。