当前位置： 首页 > news >正文

设计模式精讲 Day 19：观察者模式（Observer Pattern）

news 2025/7/1 11:41:18

【设计模式精讲 Day 19】观察者模式（Observer Pattern）

开篇

在“设计模式精讲”系列的第19天，我们聚焦于观察者模式（Observer Pattern）。作为行为型设计模式之一，观察者模式是实现对象间一对多依赖关系的经典方式，广泛应用于事件驱动系统、状态变化通知、消息订阅等场景。

本篇文章将从理论到实践全面讲解观察者模式，包括其核心思想、结构组成、适用场景、代码实现、优缺点分析、实际案例和与其他模式的关系。通过深入解析，帮助开发者理解如何在 Java 项目中合理使用该模式，提升系统的可维护性和扩展性。

模式定义

观察者模式是一种行为型设计模式，它定义了对象之间的一对多依赖关系，当一个对象的状态发生变化时，所有依赖它的对象都会自动收到通知并更新。

核心思想：解耦发布者与订阅者，实现松耦合的通信机制。

模式结构

观察者模式包含以下几个关键角色：

角色说明
Subject（主题）被观察的对象，它维护一个观察者列表，并提供注册、移除和通知观察者的接口。
Observer（观察者）接收主题通知的接口，通常定义一个 update() 方法。
ConcreteSubject（具体主题）实现 Subject 接口，管理观察者列表，并在状态变化时通知它们。
ConcreteObserver（具体观察者）实现 Observer 接口，响应主题的通知并执行相应操作。

文字描述类图结构

  • Subject 是抽象接口，包含 registerObserver(), removeObserver(), notifyObservers() 方法。
  • ConcreteSubject 实现 Subject，并在内部维护一个 List<Observer>。
  • Observer 是一个接口，定义 update() 方法。
  • ConcreteObserver 实现 Observer，并根据 update() 方法进行处理。

适用场景

观察者模式适用于以下典型场景：

场景说明
事件驱动系统如 GUI 界面中的按钮点击、表单提交等事件触发后的回调处理。
状态变更通知当某个对象的状态发生变化时，需要通知多个相关对象。
消息广播系统如消息队列、邮件通知、实时数据推送等。
日志记录与监控当系统发生特定事件时，通知多个日志或监控模块。

实现方式

以下是一个完整的 Java 实现示例，展示了观察者模式的基本结构。

1. 定义观察者接口

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

2. 定义主题接口

// Subject.java
import java.util.List;public interface Subject {void registerObserver(Observer observer);void removeObserver(Observer observer);void notifyObservers(String message);
}

3. 实现具体主题

// ConcreteSubject.java
import java.util.ArrayList;
import java.util.List;public class ConcreteSubject implements Subject {private List<Observer> observers = new ArrayList<>();@Overridepublic void registerObserver(Observer observer) {observers.add(observer);}@Overridepublic void removeObserver(Observer observer) {observers.remove(observer);}@Overridepublic void notifyObservers(String message) {for (Observer observer : observers) {observer.update(message);}}// 模拟状态变化public void changeState(String newState) {System.out.println("Subject state changed to: " + newState);notifyObservers(newState);}
}

4. 实现具体观察者

// ConcreteObserverA.java
public class ConcreteObserverA implements Observer {@Overridepublic void update(String message) {System.out.println("ConcreteObserverA received: " + message);}
}// ConcreteObserverB.java
public class ConcreteObserverB implements Observer {@Overridepublic void update(String message) {System.out.println("ConcreteObserverB received: " + message);}
}

5. 测试类

// ObserverTest.java
public class ObserverTest {public static void main(String[] args) {Subject subject = new ConcreteSubject();Observer observerA = new ConcreteObserverA();Observer observerB = new ConcreteObserverB();subject.registerObserver(observerA);subject.registerObserver(observerB);// 模拟状态变化subject.changeState("New State 1");subject.changeState("New State 2");// 移除观察者subject.removeObserver(observerA);subject.changeState("New State 3");}
}
输出结果
Subject state changed to: New State 1
ConcreteObserverA received: New State 1
ConcreteObserverB received: New State 1
Subject state changed to: New State 2
ConcreteObserverA received: New State 2
ConcreteObserverB received: New State 2
Subject state changed to: New State 3
ConcreteObserverB received: New State 3

工作原理

观察者模式的核心在于解耦发布者和订阅者。具体工作流程如下：

  1. 注册阶段：观察者向主题注册自己，主题维护一个观察者列表。
  2. 通知阶段：当主题状态发生变化时，调用 notifyObservers() 方法遍历观察者列表，逐个调用它们的 update() 方法。
  3. 更新阶段：每个观察者根据接收到的消息执行相应的业务逻辑。

这种机制使得主题不需要知道具体的观察者是谁，只需关注通知即可，从而实现高内聚、低耦合的设计目标。

优缺点分析

优点缺点
解耦发布者与订阅者，提高系统的灵活性和可维护性。可能导致内存泄漏，如果未及时移除观察者，可能会造成资源浪费。
支持动态添加/删除观察者，适应性强。调试困难，因为观察者的更新逻辑分散在多个地方。
符合开闭原则，新增观察者无需修改主题代码。性能问题，大量观察者时可能影响系统性能。

案例分析：电商平台订单状态通知系统

问题描述

某电商平台需要在订单状态发生变化时，通知多个下游系统（如库存系统、物流系统、用户通知系统），以完成后续操作。传统的做法是让订单服务直接调用各个系统的接口，导致耦合度高、难以维护。

解决方案

使用观察者模式，将订单状态变化作为主题，各个下游系统作为观察者注册到订单服务中。当订单状态改变时，订单服务通知所有观察者，由观察者自行处理自己的业务逻辑。

实现代码

// OrderStatus.java
public enum OrderStatus {PENDING, PROCESSING, SHIPPED, DELIVERED
}// Order.java
import java.util.List;public class Order {private OrderStatus status;private List<Observer> observers = new ArrayList<>();public void registerObserver(Observer observer) {observers.add(observer);}public void setStatus(OrderStatus status) {this.status = status;notifyObservers();}private void notifyObservers() {for (Observer observer : observers) {observer.update(this.status.toString());}}
}

// InventorySystem.java
public class InventorySystem implements Observer {@Overridepublic void update(String status) {if (status.equals("PROCESSING")) {System.out.println("Inventory system: Deducting stock for order.");}}
}// LogisticsSystem.java
public class LogisticsSystem implements Observer {@Overridepublic void update(String status) {if (status.equals("SHIPPED")) {System.out.println("Logistics system: Preparing for shipment.");}}
}// NotificationSystem.java
public class NotificationSystem implements Observer {@Overridepublic void update(String status) {if (status.equals("DELIVERED")) {System.out.println("Notification system: Sending delivery confirmation to user.");}}
}

// Main.java
public class Main {public static void main(String[] args) {Order order = new Order();order.registerObserver(new InventorySystem());order.registerObserver(new LogisticsSystem());order.registerObserver(new NotificationSystem());order.setStatus(OrderStatus.PROCESSING);order.setStatus(OrderStatus.SHIPPED);order.setStatus(OrderStatus.DELIVERED);}
}
输出结果
Inventory system: Deducting stock for order.
Logistics system: Preparing for shipment.
Notification system: Sending delivery confirmation to user.

这个案例展示了如何利用观察者模式实现订单状态的多系统同步，降低了系统间的耦合度，提高了可扩展性。

与其他模式的关系

与策略模式的区别

  • 策略模式：定义一系列算法，封装起来，使它们可以互相替换。适用于需要动态切换算法的情况。
  • 观察者模式：用于对象间的一对多依赖，适用于状态变化通知的场景。

两者都属于行为型模式，但用途不同，不能直接替代。

与命令模式的结合

命令模式可以与观察者模式结合使用，例如在事件驱动系统中，将事件封装为命令对象，由观察者执行。

与中介者模式的对比

  • 中介者模式：通过一个中介对象协调多个对象之间的交互，避免直接引用。
  • 观察者模式：通过主题通知观察者，实现一对多通信。

二者都可用于减少对象间的耦合，但解决的问题类型不同。

总结

通过本篇文章的学习，我们掌握了观察者模式的核心思想、实现方式以及在实际项目中的应用。观察者模式是一种非常实用的行为型设计模式，尤其适合需要对象间松耦合通信的场景。

关键知识点回顾

  • 观察者模式通过主题和观察者之间的解耦，实现灵活的通知机制。
  • 实现过程中需要注意观察者的生命周期管理，避免内存泄漏。
  • 在实际项目中，观察者模式常用于事件驱动系统、状态变更通知等场景。

下一天预告

明天我们将讲解 状态模式（State Pattern），它是行为型模式的一种，用于封装对象的状态转换逻辑，非常适合处理具有复杂状态变化的系统。敬请期待！

标签

设计模式, Java开发, 观察者模式, 行为型模式, 面向对象设计, 设计模式精讲, Spring框架, 事件驱动, 松耦合

文章简述

本文详细讲解了“设计模式精讲”系列的第19天内容——观察者模式。通过理论与实践相结合的方式，介绍了观察者模式的核心思想、结构组成、适用场景、完整 Java 实现、优缺点分析以及真实项目中的应用案例。文章还深入探讨了该模式与其他设计模式的关系，并给出了在 Java 标准库和主流框架中的实际应用实例。通过本篇文章的学习，读者能够掌握如何在实际项目中合理使用观察者模式，提升系统的可维护性和扩展性。

http://www.dtcms.com/a/263253.html

相关文章：

  • 自由学习记录（64）
  • 傅里叶变换理解
  • Instruct-GPT奖励模型的损失函数与反向传播机制解析
  • opencv入门(1)环境变量配置
  • FOC中V/F启动和I/F启动的区别
  • 零成本接入+企业级部署：2025年AI大模型实战指南
  • 企业自建云概念解读｜私有云、专有云、混合云、分布式云、企业云
  • 【零基础学AI】第14讲：支持向量机实战 - 文本分类系统
  • 华为云 Flexus+DeepSeek 征文｜基于 Dify 平台开发智能客服 AI Agent 的完整实战指南
  • python+uniapp基于微信小程序蜀味道江湖餐饮管理系统nodejs+java
  • 矩阵方程 线性代数
  • 微服务架构下的JWT深度实践：从原理到安全最佳实践
  • CppCon 2018 学习:An allocator is a handle to a heap Lessons learned from std::pmr
  • guava限流器RateLimiter源码详解
  • Codis的槽位迁移与ConcurrentHashMap扩容的相似之处
  • 智慧水利物联感知网解决方案PPT(45页)
  • 编程实践：opencv支持freetype
  • uniapp+vue2 ba-tree-picker下拉项多选 树形层级选择器（支持单选、多选、父级选择、映射）
  • ChatGPT、DeepSeek等大语言模型助力高效办公、论文与项目撰写、数据分析、机器学习与深度学习建模等科研应用
  • vipmro网站商品详情接口技术解析
  • Array.from()方法解析与应用
  • 容器化 vs 虚拟机：什么时候该用 Docker？什么时候必须用 VM？
  • 本地部署kafka4.0
  • RPC-Client模块
  • 从0到亿级数据抓取：亮数据如何破解全球采集难题？
  • 《燕云十六声》全栈技术架构深度解析
  • 算法与数据结构：解决问题的黄金搭档
  • 后台管理系统的诞生 - 利用AI 1天完成整个后台管理系统的微服务后端+前端
  • spring-ai-alibaba 1.0.0.2 学习（四）——语句切分器、文档检索拦截器
  • JavaEE初阶第五期：解锁多线程，从 “单车道” 到 “高速公路” 的编程升级（三）