观察者模式

最新推荐文章于 2024-10-01 18:51:18 发布
最新推荐文章于 2024-10-01 18:51:18 发布
阅读量534 收藏
点赞数
分类专栏： 设计模式 文章标签： 观察者模式 java 开发语言 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44061521/article/details/131338991
版权

观察者模式

简介

所谓观察者模式，就是一旦观察的对象发生了改变，立马通知所有观察者做出相应的改变。是不是和发布订阅很像，因此观察者模式又叫发布订阅模式。

观察者使用范围十分广泛，比如我们关注的微信公众号有新内容，订阅的用户会有提示；又比如你在起点上观看的小说有更新，也会有消息提醒。

而一般的观察者模式由观察目标、抽象观察者、具体观察者构成。其中观察目标就可以理解为用户关注的公众号。

代码实现

初版代码实现

这里的初版代码我就直接使用菜鸟教程的代码了。

定义观察对象

/**
 * 观察目标类，观察目标类必须要知道所有订阅自己的观察者，不然无法发送更新通知给观察者们
 *
 * @author zxb 2023/6/22 9:20
 */
public class Subject {

    private List<Observe> observes = new ArrayList<>();

    private int state;

    public int getState() {
        return state;
    }

    public void setState(int state) {
        this.state = state;
        // 更新后通知所有观察者
        notifyAllObserve();
    }

    /**
     * 添加观察者
     *
     * @param observe 观察者
     */
    public void attach(Observe observe) {
        observes.add(observe);
    }

    /**
     * 删除观察者
     *
     * @param observe 观察者
     */
    public void remove(Observe observe) {
        observes.remove(observe);
    }

    /**
     * 通知所有观察者，观察目标属性发生变更
     */
    public void notifyAllObserve() {
        for (Observe observe : observes) {
            observe.update();
        }
    }
}

观察目标核心就是三个方法，一个观察者感兴趣的状态，其它可以根据具体业务扩充。

定义抽象观察者

/**
 * 抽象观察者类
 *
 * @author zxb 2023/6/22 9:22
 */
public abstract class Observe {
    protected Subject subject;

    public abstract void update();
}

抽象观察者就是要提供一个更新方法给观察目标调用。

定义具体观察者

这里有三个具体的观察者实现类。

package org.example.observe;

/**
 * @author zxb 2023/6/22 9:29
 */
public class BinaryObserver extends Observe {
    public BinaryObserver(Subject subject) {
        this.subject = subject;
        subject.attach(this);
    }
    @Override
    public void update() {
        System.out.println("BinaryObserver 感知到观察的对象发生更新，更新的内容为 : " + Integer.toBinaryString(subject.getState()));
    }
}

package org.example.observe;

/**
 * @author zxb 2023/6/22 9:29
 */
public class OctalObserver extends Observe {
    public OctalObserver(Subject subject) {
        this.subject = subject;
        subject.attach(this);
    }

    @Override
    public void update() {
        System.out.println("OctalObserver 感知到观察的对象发生更新，更新的内容为 : " + Integer.toOctalString(subject.getState()));
    }
}


package org.example.observe;

/**
 * @author zxb 2023/6/22 9:29
 */
public class HexObserver extends Observe {
    public HexObserver(Subject subject) {
        this.subject = subject;
        subject.attach(this);
    }

    @Override
    public void update() {
        System.out.println("HexObserver 感知到观察的对象发生更新，更新的内容为 : " + Integer.toHexString(subject.getState()));
    }
}

上面三个观察者分别感知观察对象的 state 状态，一但发生变化，即打印更新的内容，分别是二进制、八进制、十六进制打印。

单元测试

package org.example.observe;

/**
 * @author zxb 2023/6/22 9:37
 */
public class ObserveTest1 {
    public static void main(String[] args) {
        // 创建被感知的对象
        Subject subject = new Subject();
        // 创建观察者们
        new BinaryObserver(subject);
        new OctalObserver(subject);
        new HexObserver(subject);
        // 观察目标发生更新
        subject.setState(1);
        subject.setState(2);
    }
}

执行结果如下:
执行结果
可以看到，一但观察目标发生更新，所有观察者都会做出相应的变化。这就是观察者模式的提现。
在很多观察者模式的博客中，都会提到观察者模式容易出现循环依赖的情况，那么下面就来复现下循环依赖。

循环依赖代码实现

如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。
那么将上面的代码稍微改一下。
初版代码实现中抽象观察者关联了观察目标的引用，该引用被各自具体观察者的构造方法入参赋值。
那么如果错误编码，导致在具体观察者的构造方法中直接实例化观察对象，而不是通过入参赋值。并且，在观察对象的构造方法中实例化具体的观察者，然后调用添加观察者方法向容器中添加观察者，这样就会出现循环依赖问题。
循环依赖代码如下:

定义观察目标

package org.example.observe_circle_rely;

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

/**
 * @author zxb 2023/6/22 9:20
 */
public class Subject {


    public Subject() {
    	// 直接实例化观察者，并将观察者加入观察者容器。
        Observe binaryObserver = new BinaryObserver();
        Observe octalObserver = new OctalObserver();
        Observe hexObserver = new HexObserver();
        attach(binaryObserver);
        attach(octalObserver);
        attach(hexObserver);
    }

    private List<Observe> observes = new ArrayList<>();

    private int state;

    public int getState() {
        return state;
    }

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

    /**
     * 添加观察者
     *
     * @param observe 观察者
     */
    public void attach(Observe observe) {
        observes.add(observe);
    }

    /**
     * 删除观察者
     *
     * @param observe 观察者
     */
    public void remove(Observe observe) {
        observes.remove(observe);
    }

    public void notifyAllObserve() {
        for (Observe observe : observes) {
            observe.update();
        }
    }
}

定义抽象观察者

抽象观察者不变。和初版代码实现一致。

定义具体观察者

package org.example.observe_circle_rely;

/**
 * @author zxb 2023/6/22 9:29
 */
public class BinaryObserver extends Observe {

    public BinaryObserver() {
    	// 在构造方法中实例化观察目标。并在 update 方法中试图获取观察目标的值
        subject = new Subject();
    }

    @Override
    public void update() {
        System.out.println("BinaryObserver 感知到观察的对象发生更新，更新的内容为 : " + Integer.toBinaryString(subject.getState()));
    }
}

其余具体观察者和 BinaryObserver 一致，都是在构造方法中实例化了观察目标，就不将代码贴出来了。

单元测试

package org.example.observe_circle_rely;

/**
 * @author zxb 2023/6/22 9:37
 */
public class ObserveTest1 {
    public static void main(String[] args) {
        // 创建被感知的对象
        Subject subject = new Subject();
        // 由于向观察者容器中添加观察者对象的操作在 Subject 构造方法中做了，因此不用显示调用
        subject.setState(1);

    }
}

执行结果出现循环依赖:
循环依赖结果

这就是当观察者和观察目标直接互相严重依赖导致的问题。因此在使用观察者模式时，要注意这个问题。

最终代码实现

初版代码能够实现基本的观察者模式，但是在单元测试中，我们需要去手动创建 N 多个观察者，稍显麻烦。
并且，在抽象观察者中，关联了观察对象的引用，其实并不需要，我们只需要感知观察对象状态变更的结果就行。
且现在都是基于 Spring 环境开发，我们可以利用 Spring 的 DI 特性来简化代码。
具体代码如下:

定义观察对象

package com.example.just_boot.observe;

import org.apache.commons.lang3.ArrayUtils;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

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

/**
 * 观察目标类，观察目标类必须要知道所有订阅自己的观察者，不然无法发送更新通知给观察者们
 *
 * @author zxb 2023/6/22 9:20
 */
@Component
public class Subject implements ApplicationContextAware {

    private List<Observe> observes = new ArrayList<>();

    private int state;

    public int getState() {
        return state;
    }

    public void setState(int state) {
        this.state = state;
        // 更新后通知所有观察者
        notifyAllObserve();
    }

    /**
     * 添加观察者
     *
     * @param observe 观察者
     */
    public void attach(Observe observe) {
        observes.add(observe);
    }

    /**
     * 删除观察者
     *
     * @param observe 观察者
     */
    public void remove(Observe observe) {
        observes.remove(observe);
    }

    /**
     * 通知所有观察者，观察目标属性发生变更
     */
    public void notifyAllObserve() {
        for (Observe observe : observes) {
       		// 将更新后的结果告知观察者们
            observe.update(getState());
        }
    }

    /**
     * 从容器中获取所有观察者，在 IOC 容器启动时将观察者放入观察者容器。
     *
     * @param applicationContext IOC 容器
     * @throws BeansException exception
     */
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        String[] beanNamesForType = applicationContext.getBeanNamesForType(Observe.class);
        if (ArrayUtils.isNotEmpty(beanNamesForType)) {
            for (String beanName : beanNamesForType) {
                Observe bean = (Observe) applicationContext.getBean(beanName);
                attach(bean);
            }
        }
    }
}

定义抽象观察者

抽象观察者不再关联观察结果对象，而是将观察结果变更的属性通过入参传入。

package com.example.just_boot.observe;

/**
 * 抽象观察者类
 *
 * @author zxb 2023/6/22 9:22
 */
public abstract class Observe {
    public abstract void update(Integer result);
}

定义具体观察者

package com.example.just_boot.observe;

import org.springframework.stereotype.Component;

/**
 * @author zxb 2023/6/22 9:29
 */
@Component
public class BinaryObserver extends Observe {

    @Override
    public void update(Integer result) {
        System.out.println("BinaryObserver 感知到观察的对象发生更新，更新的内容为 : " + Integer.toBinaryString(result));
    }
}

package com.example.just_boot.observe;

import org.springframework.stereotype.Component;

/**
 * @author zxb 2023/6/22 9:29
 */
@Component
public class OctalObserver extends Observe {
    @Override
    public void update(Integer result) {
        System.out.println("OctalObserver 感知到观察的对象发生更新，更新的内容为 : " + Integer.toBinaryString(result));
    }
}

package com.example.just_boot.observe;

import org.springframework.stereotype.Component;

/**
 * @author zxb 2023/6/22 9:29
 */
@Component
public class HexObserver extends Observe {

    @Override
    public void update(Integer result) {
        System.out.println("HexObserver 感知到观察的对象发生更新，更新的内容为 : " + Integer.toBinaryString(result));
    }
}

定义 Controller

package com.example.just_boot.controller;

import com.example.just_boot.observe.Subject;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

/**
 * @author zxb 2023/6/22 13:09
 */
@RestController
@RequestMapping(path = "/observe")
public class ObserveController {

    @Resource
    private Subject subject;

    @GetMapping(path = "/")
    public String testUpdate() {
        subject.setState(15);
        return "success";
    }
}

访问 http://localhost:8080/observe/， 页面返回 success。控制台打印如下:
执行结果

总结

通过上面的迭代更新，观察者模式的代码已初显威力，但是也还有优化的地方。比如观察者对象也可以定义一个接口，定义通用的方法规范，然后定义实现类进行扩充。
设计模式代码风格多变，但是核心思想不变。
观察者模式代码的核心思想就是：
● 定义观察目标对象，在该对象中定义：添加观察者方法、删除观察者方法、通知所有观察者方法、更新自身状态的方法(观察者观察的属性)。此外，该对象中还需要有一个观察者容器，用来存放所有观察此对象的观察者。这个观察者容器必须要有，不然当观察目标发生变化，无法通知到所有观察此对象的观察者们。
● 定义抽象观察者类，该对象中一般定义一个更新方法，用于观察目标自身属性发生更新，调用此更新方法通知观察者。
● 定义具体观察者类，这里具体的观察者类一般有多个，他们在更新方法中实现当观察目标属性变更时做出的具体逻辑。

血莲丹
关注
专栏目录
Android开发模式之观察者模式
weixin_43858011的博客
10-25 2804
定义对象一种一对多的依赖关系，使得当一个对象改变状态的时候，所有依赖它的对象都会得到通知并自动更新。观察者模式是一种使用频率非常高的设计模式，最常用的地方就是订阅-发布系统。
用C++ 实现设计模式之观察者模式
12-22
观察者模式是一种软件设计模式，它定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。这种模式在处理事件驱动和实时信息更新的系统中非常常见，如股票市场的...
C# 观察者模式
熊思雨的博客
08-19 2930
在C#中，观察者模式通过定义一种一对多的依赖关系，使得当一个对象的状态发生变化时，所有依赖于它的对象都会得到通知并自动更新。4. ConcreteObserver（具体观察者）：具体的观察者，它继承或实现了观察者接口，并实现了更新方法。当接收到被观察者的通知时，它会执行相应的逻辑。3. ConcreteSubject（具体主题）：具体的被观察者，它继承或实现了主题接口，并实现了具体的业务逻辑。1. Subject（主题）：被观察者，它维护了一个观察者列表，并提供了添加、删除和通知观察者的方法。
C++观察者模式
田螺姑娘的博客
11-22 4425
C++观察者模式   当对象间存在一对多关系时，则使用观察者模式（observer pattern）。比如，当一个对象被修改时，则会自动通知发依赖它的对象。观察者模式属于行为型模式。   Observer模式是应用最多、影响最广的设计模式之一，因为Observer的一个实例Model/View/Control（MVC）结构在系统开发架构设计中有着很重要的地位和意义，MVC实现了业务逻辑和表示层的解耦。在MFC（微软基础类库）中，Doc/View（文档视图结构）提供了实现MVC的框架结构。   在GOF的《设
观察者模式实现原理
u010574271的博客
01-15 1507
前言 观察者模式定义了对象之间的一对多依赖，让多个观察者对象同时监听一个主题对象，当主题对象发生变化时，它的所有观察者都会收到通知并作出相应的动作。 观察者模式又叫发布订阅模式，需要观察者对被观察者发布的的动作进行订阅。 实现 主要类 我们新建的这几个类中，Event是事件类，用于包装触发事件的相关信息；MouseEventType接口中定义了各种事件类型；EventLisenter是监听器类，它是观察者的桥梁；Mouse是被观察者类，当它作出动作时，观察者就会反应并作出相应动作。MouseEventCa
观察者模式及其应用场景
hello_1566的博客
04-24 5994
观察者模式（Observer Design Pattern）,也叫做发布订阅模式（Publish-Subscribe Design Pattern）、模型-视图（Model-View）模式、源-监听器（Source-Listener）模式、从属者（Dependents）模式。指在对象之间定义一个一对多的依赖，当一个对象状态改变的时候，所有依赖的对象都会自动收到通知。 比如说Redis 中的基于频道的发布订阅就是观察者模式的应用： 一、观察者模式的介绍 观察者模式是一种对象行为型模式，下面就来看看观察者模式
发布订阅和观察者模式
whaleluo的博客
05-09 2759
文章目录发布订阅和观察者模式发布订阅发布订阅与观察者的区别 发布订阅和观察者模式 发布订阅 转载https://www.cnblogs.com/chris-oil/p/8733249.html 发布—订阅模式又叫观察者模式，它定义了对象间的一种一对多的关系，让多个观察者对象同时监听某一个主题对象，当一个对象发生改变时，所有依赖于它的对象都将得到通知。 现实生活中的发布-订阅模式； 比如小红最近在淘宝网上看上一双鞋子，但是呢 联系到卖家后，才发现这双鞋卖光了，但是小红对这双鞋又非常喜欢，所以呢联系卖
C++ 设计模式——观察者模式
qq_68194402的博客
08-20 1640
观察者模式（Observer Pattern）是一种常用的设计模式，属于行为型模式。它定义了一种一对多的依赖关系，使得当一个对象（主题）状态发生变化时，所有依赖于它的对象（观察者）都会得到通知并自动更新。
C++观察者模式代码实例
qqrrjj2011的博客
02-28 1597
C++观察者模式的实现示例
一文搞懂设计模式—观察者模式
BookSea的博客
02-18 1251
观察者模式（Observer Pattern）是一种常见的行为型设计模式，用于在对象之间建立一种一对多的依赖关系。当一个对象的状态发生变化时，所有依赖它的对象都将得到通知并自动更新
PHP 设计模式之观察者模式介绍
10-28
观察者模式是软件设计模式中的一种行为模式，它允许一个对象（称为主题或可观察者）在状态发生改变时通知其他对象（称为观察者）。这种模式遵循了几个重要的设计原则，如开放封闭原则、依赖倒置原则和组合复用原则，...
iOS 设计模式 观察者模式
02-18
观察者模式，也被称为发布-订阅（Publish-Subscribe）模式，是软件设计中的一种行为模式。在iOS开发中，它是一种让多个对象监听或订阅某一个主题对象的状态变化，并在状态变化时自动收到通知的方式。这种模式使得...
JAVA中常用的设计模式：单例模式，工厂模式，观察者模式
08-19
观察者模式是一种行为设计模式，它定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。这种模式常用于事件驱动编程，例如GUI组件、订阅-发布系统等。 ```...
JS设计模式之观察者模式：观察者与可观察对象的巧妙互动
前端梦工厂
09-29 1269
在前端开发中，我们经常会遇到需要对用户的操作进行响应的场景，例如页面上的按钮点击输入框内容变化等。为了实现这种响应式的设计，我们可以使用观察者模式来解耦各个组件之间的依赖关系。本文将详细介绍观察者模式的原理和实现方法，并通过实例代码演示如何使用观察者模式来实现一个简单的响应式系统。我们将从以下几个方面展开分析：基本定义和核心概念如何实现观察者模式在前端开发中的应用场景使用注意事项希望通过本文的学习，可以深入了解观察者模式的用法，并将其应用于实际开发中，提高代码的质量。观察者模式。
JavaScript ArrayBuffer的读写与类型转换
最新发布
白瑕 的博客
10-01 416
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
spring-boot 整合 mybatis
m0_72168501的博客
09-29 524
spring boot 整合 mybatis
【开源免费】基于SpringBoot+Vue.JS校园资料分享平台（JAVA毕业设计）
customer08的博客
09-30 1222
校园资料分享平台是一个B/S模式系统，采用Spring Boot框架作为开发技术，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得校园资料分享平台管理工作系统化、规范化。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值