设计模式之观察者模式

最新推荐文章于 2025-07-29 12:15:13 发布
最新推荐文章于 2025-07-29 12:15:13 发布
阅读量270 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 设计模式 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/lsdstone/article/details/118945921
本文介绍了观察者模式的概念及其在一对多关系中的应用，详细阐述了从简单的对象调用到抽象接口的演进过程。通过逐步改进，将观察者与被观察者分离，引入事件机制，最终形成了一个更灵活、可扩展的观察者模式实现。文章通过孩子哭闹的例子，展示了如何处理多个观察者和事件的具体操作，强调了模式在处理对象间依赖关系和触发机制中的优势及可能存在的问题。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

设计模式之观察者模式

思维导图

在这里插入图片描述

概述

当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知依赖它的对象。观察者模式属于行为型模式。

介绍

意图：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

主要解决：一个对象状态改变给其他对象通知的问题，而且要考虑到易用和低耦合，保证高度的协作。

何时使用：一个对象（目标对象）的状态发生改变，所有的依赖对象（观察者对象）都将得到通知，进行广播通知。

如何解决：使用面向对象技术，可以将这种依赖关系弱化。

关键代码：在抽象类里有一个 ArrayList 存放观察者们。

应用实例： 如拍卖的时候，拍卖师观察最高标价，然后通知给其他竞价者竞价。

优点：
1、观察者和被观察者是抽象耦合的。
2、建立一套触发机制

缺点：

1、如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。
2、如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。
3、观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。

观察者模式的演进

这里我们逐步模拟孩子哭了，然后家长作为观察者所产生的一系列动作

/**
 * 加入观察者
 */

class Child {
    private boolean cry = false;
    private Dad d = new Dad();

    public boolean isCry() {
        return cry;
    }

    public void wakeUp() {
        cry = true;
        d.feed();
    }
}

class Dad {
    public void feed() {
        System.out.println("dad feeding...");
    }
}

public class Main {
    public static void main(String[] args) {
        Child c = new Child();
        //do sth
        c.wakeUp();
    }
}

这里是通过对象的调用实现的一个观察逻辑，孩子哭了进入wakeUp方法，然后再调用孩子父亲喂奶的方法。

然后我们再加入多个观察者

/**
 * 加入多个观察者
 */

class Child {
    private boolean cry = false;
    private Dad dad = new Dad();
    private Mum mum = new Mum();
    private Dog dog = new Dog();


    public boolean isCry() {
        return cry;
    }

    public void wakeUp() {
        cry = true;
        dad.feed();
        dog.wang();
        mum.hug();
    }
}

class Dad {
    public void feed() {
        System.out.println("dad feeding...");
    }
}

class Mum {
    public void hug() {
        System.out.println("mum hugging...");
    }
}

class Dog {
    public void wang() {
        System.out.println("dog wang...");
    }
}

public class Main {
    public static void main(String[] args) {
        Child c = new Child();
        //do sth
        c.wakeUp();
    }
}

这里就是调用孩子醒了的wakeUp方法，在wakeUp方法里面又增加了妈妈，和狗狗这两个观察者，分别对应于孩子醒了的不同处理逻辑，但是这样一层一层的调用逻辑很混乱，观察者和被观察者都是在一个方法里面，我们可以把这些观察者串联起来，当被观察者发生变化时，则调用观察者的链条就好了。

/**
 * 分离观察者与被观察者
 */

class Child {
    private boolean cry = false;
    private List<Observer> observers = new ArrayList<>();

    {
        observers.add(new Dad());
        observers.add(new Mum());
        observers.add(new Dog());
    }


    public boolean isCry() {
        return cry;
    }

    public void wakeUp() {
        cry = true;
        for(Observer o : observers) {
            o.actionOnWakeUp();
        }
    }
}

interface Observer {
    void actionOnWakeUp();
}

class Dad implements Observer {
    public void feed() {
        System.out.println("dad feeding...");
    }

    @Override
    public void actionOnWakeUp() {
        feed();
    }
}

class Mum implements Observer {
    public void hug() {
        System.out.println("mum hugging...");
    }

    @Override
    public void actionOnWakeUp() {
        hug();
    }
}

class Dog implements Observer {
    public void wang() {
        System.out.println("dog wang...");
    }

    @Override
    public void actionOnWakeUp() {
        wang();
    }
}

public class Main {
    public static void main(String[] args) {
        Child c = new Child();
        //do sth
        c.wakeUp();
    }
}

这里我们根据观察者的共性去抽取出来一个接口（都是在宝宝醒了的前提下去做不同的事情，所以抽取actionOnWake方法），并根据需要创建出宝宝醒了这些观察者该做什么，也可以根据接口来扩展出各种观察者对于被观察者的不同行为的表现如宝宝饿了，宝宝哭了（这些情况爸爸、妈妈、狗狗这些观察者该做什么）等等，但是这里只抽取出来了前面讲的抽象观察者角色和具体观察者角色，并且很多时候观察者需要根据事件的具体情况来做更深一步的处理，上面代码对于观察的事件也没有抽取出来,就比如说这个事件发生的位置，宝宝在不同的地方哭，应该对应着不同的处理方式。

所以如下代码我们再抽取一个事件类出来，先定义为wakeUpEvent吧


/**
 * 有很多时候，观察者需要根据事件的具体情况来进行处理
 */

class Child {
    private boolean cry = false;
    private List<Observer> observers = new ArrayList<>();

    {
        observers.add(new Dad());
        observers.add(new Mum());
        observers.add(new Dog());
    }


    public boolean isCry() {
        return cry;
    }

    public void wakeUp() {
        cry = true;

        wakeUpEvent event = new wakeUpEvent(System.currentTimeMillis(), "bed");

        for(Observer o : observers) {
            o.actionOnWakeUp(event);
        }
    }
}

//事件类 fire Event
class wakeUpEvent{
    long timestamp;
    String loc;

    public wakeUpEvent(long timestamp, String loc) {
        this.timestamp = timestamp;
        this.loc = loc;
    }
}

interface Observer {
    void actionOnWakeUp(wakeUpEvent event);
}

class Dad implements Observer {
    public void feed() {
        System.out.println("dad feeding...");
    }

    @Override
    public void actionOnWakeUp(wakeUpEvent event) {
        feed();
    }
}

class Mum implements Observer {
    public void hug() {
        System.out.println("mum hugging...");
    }

    @Override
    public void actionOnWakeUp(wakeUpEvent event) {
        hug();
    }
}

class Dog implements Observer {
    public void wang() {
        System.out.println("dog wang...");
    }

    @Override
    public void actionOnWakeUp(wakeUpEvent event) {
        wang();
    }
}

public class Main {
    public static void main(String[] args) {
        Child c = new Child();
        //do sth
        c.wakeUp();
    }
}

如上所示，我们就能对事件进行扩展了，我们可以根据事件对象中的事件发生事件，和事件发生的位置，在观察者对应的方法中做相关判断从而拓展观察者在事件发生的不同情况下的行为模式，当然这样扩展事件的话是非常不方便的，比如说对于不同的宝宝，观察者应该也要有不同的观察方式，所以这里就需要创建一个事件源对象。


/**
 * 有很多时候，观察者需要根据事件的具体情况来进行处理
 * 大多数时候，我们处理事件的时候，需要事件源对象
 */

class Child {
    private boolean cry = false;
    private List<Observer> observers = new ArrayList<>();

    {
        observers.add(new Dad());
        observers.add(new Mum());
        observers.add(new Dog());
    }


    public boolean isCry() {
        return cry;
    }

    public void wakeUp() {
        cry = true;

        wakeUpEvent event = new wakeUpEvent(System.currentTimeMillis(), "bed", this);

        for(Observer o : observers) {
            o.actionOnWakeUp(event);
        }
    }
}

class wakeUpEvent{
    long timestamp;
    String loc;
    Child source;

    public wakeUpEvent(long timestamp, String loc, Child source) {
        this.timestamp = timestamp;
        this.loc = loc;
        this.source = source;
    }
}

interface Observer {
    void actionOnWakeUp(wakeUpEvent event);
}

class Dad implements Observer {
    public void feed() {
        System.out.println("dad feeding...");
    }

    @Override
    public void actionOnWakeUp(wakeUpEvent event) {
        feed();
    }
}

class Mum implements Observer {
    public void hug() {
        System.out.println("mum hugging...");
    }

    @Override
    public void actionOnWakeUp(wakeUpEvent event) {
        hug();
    }
}

class Dog implements Observer {
    public void wang() {
        System.out.println("dog wang...");
    }

    @Override
    public void actionOnWakeUp(wakeUpEvent event) {
        wang();
    }
}

public class Main {
    public static void main(String[] args) {
        Child c = new Child();
        //do sth
        c.wakeUp();
    }
}

如上所示，传入了事件的源对象我们在观察者调用的时候可以根据传入的对象来做进一步的扩展，但是对于不同的事件来说扩展会很不方便，也会出现逻辑混乱的情况，所以我们将事件类给抽取出来。


/**
 * 有很多时候，观察者需要根据事件的具体情况来进行处理
 * 大多数时候，我们处理事件的时候，需要事件源对象
 * 事件也可以形成继承体系
 */

class Child {
    private boolean cry = false;
    private List<Observer> observers = new ArrayList<>();

    {
        observers.add(new Dad());
        observers.add(new Mum());
        observers.add(new Dog());
        observers.add((e)->{
            System.out.println("ppp");
        });
        //hook callback function
    }


    public boolean isCry() {
        return cry;
    }

    public void wakeUp() {
        cry = true;

        wakeUpEvent event = new wakeUpEvent(System.currentTimeMillis(), "bed", this);

        for(Observer o : observers) {
            o.actionOnWakeUp(event);
        }
    }
}

abstract class Event<T> {
    abstract T getSource();
}

class wakeUpEvent extends Event<Child>{
    long timestamp;
    String loc;
    Child source;

    public wakeUpEvent(long timestamp, String loc, Child source) {
        this.timestamp = timestamp;
        this.loc = loc;
        this.source = source;
    }

    @Override
    Child getSource() {
        return source;
    }
}

interface Observer {
    void actionOnWakeUp(wakeUpEvent event);
}

class Dad implements Observer {
    public void feed() {
        System.out.println("dad feeding...");
    }

    @Override
    public void actionOnWakeUp(wakeUpEvent event) {
        feed();
    }
}

class Mum implements Observer {
    public void hug() {
        System.out.println("mum hugging...");
    }

    @Override
    public void actionOnWakeUp(wakeUpEvent event) {
        hug();
    }
}

class Dog implements Observer {
    public void wang() {
        System.out.println("dog wang...");
    }

    @Override
    public void actionOnWakeUp(wakeUpEvent event) {
        wang();
    }
}

public class Main {
    public static void main(String[] args) {
        Child c = new Child();
        //do sth
        c.wakeUp();
    }
}

如上所示则是将整体的一个事件抽取出来了，有一个确定的规范也便于去扩展，但是在每个方法内去写我们要添加哪些观察者会导致程序的耦合度比较高,所以我们再将抽象主题角色和具体主题角色给抽取出来。

//抽象主题角色
 abstract class Subject{
    protected List<Observer> observers = new ArrayList<>();
    public void add(Observer observer)
    {
        observers.add(observer);
    }
    public void remove(Observer observer)
    {
        observers.remove(observer);
    }
    public abstract void call();
}

//具体主题角色
class Child extends Subject {

    public void call() {
        wakeUpEvent event = new wakeUpEvent(System.currentTimeMillis(), "bed", this);
        for(Observer o : observers)
        {
            o.actionOnWakeUp(event);
        }
    }
}

abstract class Event<T> {
    abstract T getSource();
}

class wakeUpEvent extends Event<Child>{
    long timestamp;
    String loc;
    Child source;

    public wakeUpEvent(long timestamp, String loc, Child source) {
        this.timestamp = timestamp;
        this.loc = loc;
        this.source = source;
    }

    @Override
    Child getSource() {
        return source;
    }
}
//抽象观察者角色
interface Observer {
    void actionOnWakeUp(wakeUpEvent event);
}
//具体观察者角色
class Dad implements Observer {
    public void feed() {
        System.out.println("dad feeding...");
    }

    @Override
    public void actionOnWakeUp(wakeUpEvent event) {
        feed();
    }
}

class Mum implements Observer {
    public void hug() {
        System.out.println("mum hugging...");
    }

    @Override
    public void actionOnWakeUp(wakeUpEvent event) {
        hug();
    }
}

class Dog implements Observer {
    public void wang() {
        System.out.println("dog wang...");
    }

    @Override
    public void actionOnWakeUp(wakeUpEvent event) {
        wang();
    }
}

public class Main {
    public static void main(String[] args) {
        Subject c = new Child();
        c.add(new Dad());
        c.add(new Mum());
        c.add(new Dog());
        c.call();
    }
}

如上就是抽取出抽象主题角色和具体主题角色的代码了。

观察者设计模式模式
哈
10-31 2232
观察者模式 观察者模式（Observer，又被称为模型（Model）-视图（View）模式、发布-订阅模式）。其目的是用来定义对象间的一种一对多的依赖关系，以便当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。观察者塔式统通常被用来实现事件处理系统。 在观察者模式中，主题是通知的发布者，它发出通知时并不需要知道谁是它的观察者，可以有任意数目的观察者订阅并接收通知。观察者模式不仅...
观察者模式
ThinkWon的博客
09-25 5469
当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知它的依赖对象。观察者模式属于行为型模式。 介绍 意图：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。 主要解决：一个对象状态改变给其他对象通知的问题，而且要考虑到易用和低耦合，保证高度的协作。 何时使用：一个对象（目标对象）...
设计模式之禅-观察者模式
gclhaha的博客
02-23 191
观察者模式 例子 韩非子和李斯。李斯监控韩非子，报信给秦王。 public interface IHanFeiZi { void haveBreakfast(); void haveFun(); } public interface Observable { void addObserver(Observer observer); void deleteObserver(Observer observer); void notifyObservers(String
【设计模式】观察者模式 ( 简介 | 适用场景 | 优缺点 | 代码示例 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
08-17 7540
一、观察者模式简介、 二、观察者模式适用场景、 三、观察者模式优缺点、 四、观察者模式代码示例、 1、被观察者、 2、观察者、 3、通知类、 4、测试类、 五、JDK 中的观察者模式支持类、 1、Observable、 2、Observer、
Java设计模式之观察者模式详解
m0_73941339的博客
06-05 1493
观察者模式是一种非常实用的设计模式，它提供了一种对象之间的一对多依赖关系，使得当一个对象的状态发生变化时，所有依赖它的对象都会得到通知并自动更新。Java 提供了内置的支持，使得实现观察者模式变得更加简单。在实际开发中，观察者模式被广泛应用于各种场景，如 GUI 事件处理、消息队列、状态管理等。通过合理使用观察者模式，可以使代码更加灵活、可维护和可扩展。
Java设计模式之观察者模式
cxbtdd的博客
11-02 2262
观察者模式（Observer），又叫发布-订阅模式（Publish/Subscribe），是一种行为型模式，定义对象间一对多的依赖关系（注册），使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知并自动更新（通知）。Observer 接口是抽象观察者，它监视目标对象的变化，当目标对象发生变化时，观察者得到通知，并调用 void update(Observable o,Object arg) 方法，进行相应的工作。2.当观察者对象很多时，通知的发布会花费很多时间，影响程序的效率。
设计模式之观察者模式.pdf
04-11
### 设计模式之观察者模式详解 #### 一、观察者模式概述 观察者模式（Observer Pattern）是一种常用的行为设计模式，它允许对象之间建立一种一对多的关系，即多个对象可以监听一个对象的状态变化，当这个对象的...
PHP设计模式之观察者模式(Observer)详细介绍和代码实例
10-26
观察者模式是一种行为设计模式，它定义了对象间的一种一对多的依赖关系，使得当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。这种模式经常用于实现软件的分布式事件通知系统，例如，图形...
PHP 设计模式之观察者模式介绍
10-28
观察者模式是软件设计模式中的一种行为模式，它允许一个对象（称为主题或可观察者）在状态发生改变时通知其他对象（称为观察者）。这种模式遵循了几个重要的设计原则，如开放封闭原则、依赖倒置原则和组合复用原则，...
【JavaEE】多线程（一）
最新发布
stillaliveQEJ的博客
07-29 235
嘿嘿，是不是有点绕晕了，可以这样理解，CPU是一个工厂，进程是工厂中不同的流水线，每一条流水线上都拥有一定的机器和原料（资源）用来加工，线程则是流水线上的工人，轮流在这条流水线上工作，每条流水线的工人使用的都是这条流水线上的资源。通过前面的内容我们已经知道，计算机中运行的程序都是由操作系统来管理的，进程则是操作系统分配资源的基本单位，为了提升CPU的运行效率，我们采用分时复用、多线程等方法进行多个程序的并发、并行执行。还有可能，线程1、2在一个核心上来回切换，线程3在另一个核心上和其他进程的线程来回切换。
MyBatis-Plus 与 Spring 新手指南
qq_31619295的博客
07-25 1199
泛型机制: 确保类型安全和代码提示继承体系: 提供丰富的基础功能注解映射: 简化配置，提高开发效率Spring集成: 无缝融入Spring生态掌握这些核心概念，就能快速理解和使用MyBatis-Plus进行数据访问层开发。
Sql server开挂的OPENJSON
清风弄影
07-27 1077
摘要：SQL Server 2019的OPENJSON功能大幅简化了JSON数据处理。相比SQL Server 2008需要自定义表类型来传递表参数的方式，新版本只需将JSON字符串作为参数传递，通过OPENJSON解析即可。该功能支持单层和嵌套JSON结构，可指定字段名称和类型，还能处理复杂层级数据。从SQL Server 2016开始引入的JSON支持，不仅提高了开发效率，还影响了表结构设计，许多原本需要主从表结构的场景现在用单表配合JSON字段就能实现，大大简化了数据库操作。
9.c语言常用算法
chxii的专栏
07-28 482
从数组的第一个元素开始，逐个与目标值进行比较，直到找到目标值或查找完整个数组。
Spring AI 项目实战（二十）：基于Spring Boot + AI + DeepSeek的智能环境监测与分析平台（附完整源码）
博客
07-26 645
本文介绍了基于Spring Boot和DeepSeek大语言模型开发的智能环保监测系统。该系统实现了多类型传感器数据采集、实时监测、AI异常检测、污染源识别、趋势预测和治理方案推荐等功能，采用前后端分离架构，整合了Spring Boot、Vue3、MySQL等技术栈。项目通过AI技术提升了环保监测的智能化水平，解决了传统系统在实时性、分析能力和预警机制等方面的不足。
9：java学习笔记：do-while语句
2301_76578848的博客
07-26 654
摘要：do-while循环与while循环结构相反，先执行循环体再判断条件（至少执行一次）。其语法为do{...}while(条件);，末尾分号不可省略。典型应用场景包括菜单交互（如游戏选项、学生系统），需确保首次必执行且持续验证输入。例如：用户输入正整数时，若值≤0则重复提示；菜单系统中，选项非退出码（如4）时循环显示。尽管使用频率低于其他循环，但在强制首次执行的场景中不可或缺。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值