23种设计模式之四：观察者模式

原创 已于 2025-08-07 17:03:51 修改 · 353 阅读 · 3 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#设计模式 #观察者模式
于 2025-08-06 16:15:30 首次发布

观察者模式 (Observer Pattern)

代码示例：

git clone https://gitee.com/qq1244811434/23DesignPatterns.git

优点

  1. 实现对象间解耦
  2. 支持广播通信，灵活性高
  3. 动态添加/移除观察者

缺点

  1. 可能引发通知链，调试困难
  2. 观察者过多时影响性能

特点

  1. 一对多依赖关系
  2. 主题与观察者解耦
  3. 支持动态注册和移除观察者

 应用场景

  1. 事件处理系统
  2. 消息推送系统
  3. 股票价格变化通知

测试

    /**
     * 演示观察者模式
     */
    @GetMapping("/observer")
    public Map<String, Object> demonstrateObserver() {
        Map<String, Object> result = new HashMap<>();
        result.put("pattern", "观察者模式");
        result.put("description", "定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象");
        
        // 执行观察者模式演示
        observerPattern.demonstrateObserverPattern();
        
        result.put("message", "观察者模式演示完成，请查看控制台输出");
        return result;
    }

输出结果：

{
    "pattern": "观察者模式",
    "description": "定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象",
    "message": "观察者模式演示完成，请查看控制台输出"
}

控制台输出内容:
=== 新闻发布观察者模式演示 ===
观察者 张三 已注册
观察者 李四 已注册
观察者 王五 已注册
发布新闻: 重大新闻：Spring Boot 3.0 正式发布！
张三 收到通知: 重大新闻：Spring Boot 3.0 正式发布！
李四 收到通知: 重大新闻：Spring Boot 3.0 正式发布！
王五 收到通知: 重大新闻：Spring Boot 3.0 正式发布！
观察者 李四 已移除
发布新闻: 技术更新：Java 17 成为新的LTS版本
张三 收到通知: 技术更新：Java 17 成为新的LTS版本
王五 收到通知: 技术更新：Java 17 成为新的LTS版本

=== 股票价格观察者模式演示 ===
股票观察者 投资者A 已注册
股票观察者 投资者B 已注册
股票观察者 投资者C 已注册
投资者A 收到股票价格变化通知: 股票价格从 100.00 变为 110.00，上涨了 10.00
投资者B 收到股票价格变化通知: 股票价格从 100.00 变为 110.00，上涨了 10.00
投资者C 收到股票价格变化通知: 股票价格从 100.00 变为 110.00，上涨了 10.00
投资者A 收到股票价格变化通知: 股票价格从 110.00 变为 105.00，下跌了 5.00
投资者B 收到股票价格变化通知: 股票价格从 110.00 变为 105.00，下跌了 5.00
投资者C 收到股票价格变化通知: 股票价格从 110.00 变为 105.00，下跌了 5.00
投资者A 收到股票价格变化通知: 股票价格从 105.00 变为 120.00，上涨了 15.00
投资者B 收到股票价格变化通知: 股票价格从 105.00 变为 120.00，上涨了 15.00
投资者C 收到股票价格变化通知: 股票价格从 105.00 变为 120.00，上涨了 15.00

完整代码

package com.example.patterns.observer;

import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.List;

/**
 * 观察者模式演示
 * 
 * 观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。
 * 当主题对象发生变化时，它的所有依赖者（观察者）都会收到通知并自动更新。
 * 
 * 应用场景：
 * - 事件处理系统
 * - 消息推送系统
 * - 股票价格变化通知
 * - 用户状态变化通知
 */
@Component
public class ObserverPattern {

    /**
     * 观察者接口 - 定义观察者的共同行为
     * 抽象观察者，具体观察者需要实现此接口
     */
    public interface Observer {
        /**
         * 更新方法，当被观察者状态改变时调用
         * 
         * @param message 更新消息
         */
        void update(String message);
        
        /**
         * 获取观察者名称
         * 
         * @return 观察者名称
         */
        String getObserverName();
    }

    /**
     * 具体观察者A
     */
    public static class ConcreteObserverA implements Observer {
        private String name;

        public ConcreteObserverA(String name) {
            this.name = name;
        }

        @Override
        public void update(String message) {
            System.out.println(name + " 收到通知: " + message);
        }

        @Override
        public String getObserverName() {
            return name;
        }
    }

    /**
     * 具体观察者B
     */
    public static class ConcreteObserverB implements Observer {
        private String name;

        public ConcreteObserverB(String name) {
            this.name = name;
        }

        @Override
        public void update(String message) {
            System.out.println(name + " 收到通知: " + message);
        }

        @Override
        public String getObserverName() {
            return name;
        }
    }

    /**
     * 主题接口 - 被观察者即目标对象。
     * 当被改变时，将通知所有观察者
     * 抽象主题，所有具体主题需要实现此接口
     * 可以有多个观察者。当主题被改变时，通知其所有观察者
     */
    public interface Subject {
        /**
         * 注册观察者
         * 
         * @param observer 观察者
         */
        void registerObserver(Observer observer);

        /**
         * 移除观察者
         * 
         * @param observer 观察者
         */
        void removeObserver(Observer observer);

        /**
         * 通知所有观察者
         * 
         * @param message 通知消息
         */
        void notifyObservers(String message);
    }

    /**
     * 具体主题 - 新闻发布者
     */
    public static class NewsPublisher implements Subject {
        private List<Observer> observers = new ArrayList<>();
        private String news;

        @Override
        public void registerObserver(Observer observer) {
            if (!observers.contains(observer)) {
                observers.add(observer);
                System.out.println("观察者 " + observer.getObserverName() + " 已注册");
            }
        }

        @Override
        public void removeObserver(Observer observer) {
            observers.remove(observer);
            System.out.println("观察者 " + observer.getObserverName() + " 已移除");
        }

        @Override
        public void notifyObservers(String message) {
            System.out.println("发布新闻: " + message);
            for (Observer observer : observers) {
                observer.update(message);
            }
        }

        /**
         * 发布新闻
         * 
         * @param news 新闻内容
         */
        public void publishNews(String news) {
            this.news = news;
            notifyObservers(news);
        }

        public String getNews() {
            return news;
        }
    }

    /**
     * 股票价格观察者模式演示
     */
    public static class StockPriceSubject implements Subject {
        private List<Observer> observers = new ArrayList<>();
        private double price;

        public StockPriceSubject(double initialPrice) {
            this.price = initialPrice;
        }

        @Override
        public void registerObserver(Observer observer) {
            if (!observers.contains(observer)) {
                observers.add(observer);
                System.out.println("股票观察者 " + observer.getObserverName() + " 已注册");
            }
        }

        @Override
        public void removeObserver(Observer observer) {
            observers.remove(observer);
            System.out.println("股票观察者 " + observer.getObserverName() + " 已移除");
        }

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

        /**
         * 更新股票价格
         * 
         * @param newPrice 新价格
         */
        public void setPrice(double newPrice) {
            double oldPrice = this.price;
            this.price = newPrice;
            
            String change = newPrice > oldPrice ? "上涨" : "下跌";
            double changeAmount = Math.abs(newPrice - oldPrice);
            String message = String.format("股票价格从 %.2f 变为 %.2f，%s了 %.2f", 
                oldPrice, newPrice, change, changeAmount);
            
            notifyObservers(message);
        }

        public double getPrice() {
            return price;
        }
    }

    /**
     * 股票投资者观察者
     */
    public static class StockInvestor implements Observer {
        private String name;
        private double buyPrice;

        public StockInvestor(String name, double buyPrice) {
            this.name = name;
            this.buyPrice = buyPrice;
        }

        @Override
        public void update(String message) {
            System.out.println(name + " 收到股票价格变化通知: " + message);
            // 这里可以添加投资决策逻辑
        }

        @Override
        public String getObserverName() {
            return name;
        }
    }

    /**
     * 演示观察者模式的使用
     */
    public void demonstrateObserverPattern() {
        System.out.println("=== 新闻发布观察者模式演示 ===");
        
        // 创建主题（新闻发布者）
        NewsPublisher publisher = new NewsPublisher();
        
        // 创建观察者（新闻订阅者）
        // 观察者之间没有联系，可以更便于进行系统拓展符合开闭原则
        Observer observer1 = new ConcreteObserverA("张三");
        Observer observer2 = new ConcreteObserverB("李四");
        Observer observer3 = new ConcreteObserverA("王五");
        
        // 注册观察者
        publisher.registerObserver(observer1);
        publisher.registerObserver(observer2);
        publisher.registerObserver(observer3);
        
        // 发布新闻
        //目标对象被改变，依赖于此的对象即观察者123都将接收到通知
        //观察者模式只能通知观察者目标发生了变化，无法得知如何发生变化
        publisher.publishNews("重大新闻：Spring Boot 3.0 正式发布！");
        
        // 移除一个观察者
        publisher.removeObserver(observer2);
        
        // 再次发布新闻
        publisher.publishNews("技术更新：Java 17 成为新的LTS版本");

        System.out.println("\n=== 股票价格观察者模式演示 ===");
        
        // 创建股票价格主题
        StockPriceSubject stockSubject = new StockPriceSubject(100.0);
        
        // 创建股票投资者观察者
        Observer investor1 = new StockInvestor("投资者A", 95.0);
        Observer investor2 = new StockInvestor("投资者B", 105.0);
        Observer investor3 = new StockInvestor("投资者C", 100.0);
        
        // 注册投资者
        stockSubject.registerObserver(investor1);
        stockSubject.registerObserver(investor2);
        stockSubject.registerObserver(investor3);
        
        // 模拟股票价格变化即目标对象被改变时观察者接收到通知
        // 可以修改setprice方法，将价格具体变化原因细节告知给各个观察者
        stockSubject.setPrice(110.0);  // 价格上涨
        stockSubject.setPrice(105.0);  // 价格下跌
        stockSubject.setPrice(120.0);  // 价格大幅上涨
    }
}

UML:

23种设计模式常用模式
Angelia Zheng
08-08 1万+
设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。 根据设计模...
行为设计模式之观察者模式
ycfn97的博客
07-22 1631
23种设计模式： 本文通过案例实现观察者模式，并顺便复习了一下线程安全的懒汉式单例模式。 package thread.exe0201; import java.util.ArrayList; import java.util.List; /** * 2 编写程序，在main方法中创建两个线程。线程1每隔一定时间（200ms以内的随机时间）产生一个0-100之间的随机整数，打印后将该整数放到集合中； * 共产生100个整数，全部产生后，睡眠30秒； * 在线程2中，唤醒上述睡眠的线程1，并获.
GOF23设计模式之观察者模式（observer）
dcpvpf6917的博客
01-23 196
一、观察者模式概述 　　观察者模式主要用于 1 ：N 的通知。当一个对象（目标对象 Subject 或 Observable）的状态变化时，它需要通知一系列对象（观察者对象 Observer），令它们做出响应。 　　通知观察者的方式： 　　　　（1）推 　　　　　　 每次都会把通知以广播的方式发送给所有观察者，所有观察者只能被动接收。 　　　　（2）拉 　　　　　　 观察...
23种设计模式一观察者模式
J_liaty的博客
02-14 1204
观察者模式是一种行为型设计模式，定义了对象间的一对多依赖关系，当被观察者状态变化时自动通知所有观察者。该模式包含被观察者（Subject）和观察者（Observer）两个核心角色，实现松耦合、动态绑定和广播通信。文章介绍了两种实现方式：基于Java内置的Observable/Observer类（已弃用）和更推荐的自定义接口实现。观察者模式广泛应用于框架设计（如Spring事件机制、Vue响应式原理），能提升系统的可维护性、扩展性和可测试性。通过天气监测系统的代码示例，展示了该模式的具体应用场景和工作流程。
23种设计模式之《观察者模式（Observer）》在c#中的应用及理解
yuanpan的专栏
03-06 2307
观察者模式通过将主题和观察者解耦，使得系统更加灵活和可扩展。它非常适合处理对象之间的一对多依赖关系，尤其是在需要动态通知和更新的场景中。在 C# 中，观察者模式可以通过事件和委托机制更简洁地实现，但经典的设计模式实现方式仍然有助于理解其核心思想。
23种设计模式——观察者模式
m0_69703043的博客
04-29 714
23种设计模式中的设计模式
白话设计模式之23种设计模式全解析
wj_rdk的博客
03-06 1452
大家好！在软件开发的漫漫长路上，设计模式是我们提升编程能力、优化代码结构的得力助手。但这些模式常常让人觉得晦涩难懂，今天我就想和大家一起，把那些复杂的设计模式用通俗易懂的方式讲清楚，咱们共同学习进步！
快速记忆23种设计模式
呼卓宇的博客
11-02 4365
举例说明各种设计模式，能方便大家理解
Android设计模式之23种设计模式一览
热门推荐
happy_horse的博客
03-16 2万+
Android设计模式之23种设计模式一览 一  什么是设计模式？ （1）基本定义：设计模式（Design pattern）是一套被反复使用的代码设计经验的总结。使用设计模式的目的是为了可重用代码、让代码更容易被他人理解。设计模式是是软件工程的基石脉络，如大厦的结构一样。 （2）Design pattern的四大要素：模式名称（Name），问题（Question），解决方案（Solu
23种设计模式(四)组件协作之观察者模式
小小何先生的学习之旅
10-03 468
  现代软件专业分工之后的第一个结果是“框架与应用程序的划分”，“组件协作”模式通过晚期绑定，来实现框架与应用程序之间的松耦合，是二者之间协作时常用的模式。   典型模式可以分为：Template Method，Strategy和Observer / Event。   观察者模式：在软件构建过程中，我们需要为某些对象建立一种“通知依赖关系” ---- 一个对象（目标对象）的状态发生改变，所有的依赖对象（观察者对象）都将得到通知。如果这样的依赖关系过于紧密，将使软件不能很好地抵御变化。 假设我们做一个文件分割
23种设计模式
liuhm的博客
05-01 1662
保证一个类只有一个实例，并且提供一个访问该全局访问点它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。实现了创建者和调用者分离，工厂模式分为简单工厂、工厂方法、抽象工厂模式通过代理控制对象的访问，可以在这个对象调用方法之前、调用方法之后去处理/添加新的功能。(也就是AO的P微实现)代理在原有代码乃至原业务流程都不修改的情况下，直接在业务流程中切入新代码，增加新功能，这也和Spring的（面向切面编程）很相似。
彻底搞懂设计模式DesignPattern-23种设计模式整理
Ping
08-21 1049
设计模式介绍 设计模式是程序员在面对同类软件工程设计问题所总结出来的有用的经验，模式不是代码，而是某类问题的通用解决方案， 设计模式（Design pattern）代表了最佳的实践。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。 设计模式的本质提高 软件的维护性，通用性和扩展性，并降低软件的复杂 度。 <<设计模式>> 是经典的书，作者是 Erich Gamma、 Richard Helm、 Ralph Johnson 和 John Vlissides
23种设计模式之：观察者模式
一万个小时
04-22 498
定义：定义对象间一种一对多的依赖关系，使得当每一个对象改变状态，则所有依赖于它的对象都会得到通知并自动更新。 类型：行为类模式（又被称为发布-订阅（Publish/Subscribe）模式） 类图： 在软件系统中经常会有这样的需求：如果一个对象的状态发生改变，某些与它相关的对象也要随之做出相应的变化。比如，我们要设计一个右键菜单的功能，只要在软件的有效区域内点击鼠标右键，...
23种设计模式——观察者模式(Observer Pattern)​详解
Meteors.的博客
09-01 1198
本文介绍了23种经典设计模式之——观察者模式(Observer Pattern)​的说明及使用。
23种设计模式都适用于哪些场景？
随心所欲的博客
08-17 1万+
根据对设计模式的学习，总结出各类设计模式的使用场景，了解哪些场景下适合使用哪种设计模式来解决该场景的问题，这样才能学而致用，仅仅了解设计模式但不能实践那学了又有什么用呢？下面来看看各种设计模式的使用场景（个人理仅供参考） 一、创建模式 1.工厂方法：一个工厂通过方法创建多个产品 2.抽象工厂方法：多个工厂创建多个产品族 3.建造者模式：分解构建步骤，分步构建 4.原型模式：一个对象需要多次修改部分...
23种设计模式之观察者模式
weixin_51395608的博客
12-09 1564
观察者模式（Observer Pattern）是一种行为设计模式。它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。当主题对象的状态发生变化时，会通知所有的观察者对象，使它们能够自动更新自己的状态。 例如，在新闻发布系统中，新闻机构是主题（被观察对象），订阅新闻的用户是观察者。每当新闻机构发布一条新的新闻（主题状态改变），所有订阅的用户（观察者）都会收到通知，然后可以根据自己的需求来查看这条新闻。
瑞_23种设计模式_观察者模式
阿瑞——从事Java后端，喜欢研读源码、自研框架、分享经验
03-27 2293
本文章为瑞_系列专栏之《23种设计模式》的观察者模式篇。观察者模式是一种常用的设计模式，常作用于分布式系统事件通知、业务对象交互、数据同步与缓存更新、实时数据监控等。
【设计模式】观察者模式
你若盛开，蜜蜂自来
02-12 9189
博主声明： 转载请在开头附加本文链接及作者信息，并标记为转载。本文由博主威威喵原创，请多支持与指教。 本文首发于此 博主：威威喵|博客主页：https://blog.csdn.net/smile_running 观察者模式（Observer Pattern），是使用比较多的一种设计模式，它的模型一般情况下都是一对多的模型，当然，也不排除有一对一的情况发生。观察者（...
AI Agent 设计模式：智能体交互，从 GUI 到现实世界环境
最新发布
闵浮龙的博客
06-19 189
智能体交互，是 Agent 落地的下一层能力。工具调用让 Agent 能访问系统。MCP 让工具连接更标准。GUI Agent 让 Agent 能操作没有 API 的界面。多模态交互让 Agent 能理解真实环境。• 能用 API，优先用 API。• 必须操作页面，再用 GUI Agent。• 涉及真实环境，必须加安全边界。• 涉及高风险动作，必须让人确认。• 所有动作都要有日志，所有失败都要能退出。真正可上线的交互型 Agent，不是“会点按钮”的模型。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值