java设计模式-观察者模式

这篇具有很好参考价值的文章主要介绍了java设计模式-观察者模式。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

什么是观察者模式

观察者模式(Observer)是软件设计中的一种行为模式。

它定义了对象之间的一对多关系,其中如果一个对象改变了状态,所有依赖它的对象都会自动被通知并更新。

这种模式包含了两种主要的角色,即被观察者(Subject)和观察者(Observer)。

被观察者维护了一个观察者列表,并提供了注册和删除观察者的方法,当其状态发生变化时,会遍历观察者列表,通知所有观察者。

观察者则定义了一个更新接口,用于接收被观察者的通知并进行相应的更新操作。

这种模式能够使得对象之间的耦合度降低,同时也能够提高系统的灵活性和扩展性。

简单地说,观察者模式定义了一个一对多的依赖关系,让一个或多个观察者对象监听一个主题对象。这样一来,当被观察者状态发生改变时,需要通知相应的观察者,使这些观察者对象能够自动更新。

应用场景

一个对象需要将自己的状态改变通知给其它多个对象,一个对象与它的多个依赖对象需要解耦,以便能对其修改,但不会对其它对象产生影响。

类图和角色

java设计模式-观察者模式,# 设计模式,java,java,设计模式,观察者模式

  • Subject:抽象主题(抽象被观察者),抽象主题角色把所有观察者对象保存在一个集合里,每个主题都可以有任意数量的观察者,抽象主题提供接口,可以增加和删除观察者对象。
  • ConcreteSubject:具体主题(具体被观察者),维护对所有具体观察者的引用的列表,在具体主题的内部状态发生改变时,给所有注册过的观察者发送通知。
  • Observer:抽象观察者,是观察者的抽象类,它定义了一个更新接口,在被观察对象状态改变时会被调用。
  • ConcreteObserver:具体观察者,实现抽象观察者定义的更新接口,以便在得到主题更改通知时更新自身的状态。

代码示例

模拟一个消息订阅推送的例子,有一个微信公众号服务,不定时发布一些消息,关注公众号就可以收到推送消息,取消关注就收不到推送消息。

首先定义抽象主题(抽象被观察者)接口

/**
 * 抽象主题(抽象被观察者)接口
 *
 * @author jiangkd
 * @date 2023/7/28 9:00:10
 */
public interface ISubject {

    /**
     * 注册一个观察着
     *
     * @param observer 观察者
     */
    void registerObserver(IObserver observer);

    /**
     * 移除一个观察者
     *
     * @param observer 观察者
     */
    void removeObserver(IObserver observer);

    /**
     * 通知所有的观察着
     */
    void notifyObservers();

}

然后定义我们的抽象观察者接口

/**
 * 抽象观察者接口, 所有的观察者需要实现此接口
 *
 * @author jiangkd
 * @date 2023/7/28 9:01:36
 */
public interface IObserver {

    /**
     * 观察者对象接收到通知后的逻辑处理
     *
     * @param msg 接收消息
     */
    void update(String msg);

}

接下来是具体主题(具体被观察者),也就是具体主题(被观察者)接口的实现类,实现了subject接口,对接口中的三个方法进行了实现,同时有一个List集合,用以保存注册的观察者,等需要通知观察者时,遍历该集合即可。

/**
 * 具体主题(具体被观察者)
 *
 * @author jiangkd
 * @date 2023/7/28 10:00:57
 */
@Component
public class WeChatMessage implements ISubject {

    private List<IObserver> observerList = new ArrayList<>();

    private String message;

    @Override
    public void registerObserver(IObserver observer) {
        observerList.add(observer);
    }

    @Override
    public void removeObserver(IObserver observer) {
        if (CollUtil.isNotEmpty(observerList)) {
            observerList.remove(observer);
        }
    }

    @Override
    public void notifyObservers() {
        for (IObserver iObserver : observerList) {
            iObserver.update(message);
        }
    }

    /**
     * 模拟被观察者的主题更新, 通知所有观察者
     *
     * @param message 主题更新
     */
    public void updateMessage(String message) {
        this.message = message;
        // 通知所有观察者
        notifyObservers();
    }

}

继续定义具体的观察者,这里我们模拟两个用户进行了订阅主题

/**
 * 具体的观察者1
 *
 * @author jiangkd
 * @date 2023/7/28 10:07:34
 */
@Slf4j
@Component
public class User1 implements IObserver {

    /**
     * 观察者接收消息, 知道被观察者发生了变化, 自己进行相应的处理, 这里只是测试打印日志而已
     *
     * @param msg 接收消息
     */
    @Override
    public void update(String msg) {
        log.info("我是具体的观察者之一:{}", this.getClass().getSimpleName());
        log.info("被观察者发生变化, 接收消息:{}", msg);
    }

}
/**
 * 具体的观察者2
 *
 * @author jiangkd
 * @date 2023/7/28 10:09:22
 */
@Slf4j
@Component
public class User2 implements IObserver {

    /**
     * 观察者接收消息, 知道被观察者发生了变化, 自己进行相应的处理, 这里只是测试打印日志而已
     *
     * @param msg 接收消息
     */
    @Override
    public void update(String msg) {
        log.info("我是具体的观察者之一:{}", this.getClass().getSimpleName());
        log.info("被观察者发生变化, 接收消息:{}", msg);
    }

}

最后测试一下

/**
 * @author jiangkd
 * @date 2023/7/28 10:10:34
 */
@SpringBootTest(classes = DemoApplication.class)
@RunWith(SpringRunner.class)
@Slf4j
public class ObserverTest {

    @Resource
    WeChatMessage weChatMessage;

    @Resource
    User1 user1;

    @Resource
    User2 user2;

    @Test
    public void test(){

        // 绑定被观察者和观察者
        weChatMessage.registerObserver(user1);
        weChatMessage.registerObserver(user2);

        // 模拟被观察者发生变化
        weChatMessage.updateMessage("今天推送什么呢?");

    }

}

执行结果如下:

2023-07-28 10:15:58.103 INFO 12236 — [ main] d.b.example.design_patterns.gczms.User1 : 我是具体的观察者之一:User1
2023-07-28 10:15:58.104 INFO 12236 — [ main] d.b.example.design_patterns.gczms.User1 : 被观察者发生变化, 接收消息:今天推送什么呢?
2023-07-28 10:15:58.104 INFO 12236 — [ main] d.b.example.design_patterns.gczms.User2 : 我是具体的观察者之一:User2
2023-07-28 10:15:58.104 INFO 12236 — [ main] d.b.example.design_patterns.gczms.User2 : 被观察者发生变化, 接收消息:今天推送什么呢?

记下来我们测试注销一个观察者,首先我们先再次添加一个观察者User3进行订阅主题

/**
 * 具体的观察者3
 *
 * @author jiangkd
 * @date 2023/7/28 10:18:46
 */
@Slf4j
@Component
public class User3 implements IObserver {

    /**
     * 观察者接收消息, 知道被观察者发生了变化, 自己进行相应的处理, 这里只是测试打印日志而已
     *
     * @param msg 接收消息
     */
    @Override
    public void update(String msg) {
        log.info("我是具体的观察者之一:{}", this.getClass().getSimpleName());
        log.info("被观察者发生变化, 接收消息:{}", msg);
    }

}

然后测试被观察者发生变化通知到三个订阅者,接着取消User2,只通知User1和User3

/**
 * @author jiangkd
 * @date 2023/7/28 10:10:34
 */
@SpringBootTest(classes = DemoApplication.class)
@RunWith(SpringRunner.class)
@Slf4j
public class ObserverTest {

    @Resource
    WeChatMessage weChatMessage;

    @Resource
    User1 user1;

    @Resource
    User2 user2;

    @Resource
    User3 user3;

    @Test
    public void test2(){

        // 绑定被观察者和观察者
        weChatMessage.registerObserver(user1);
        weChatMessage.registerObserver(user2);
        weChatMessage.registerObserver(user3);

        // 模拟被观察者发生变化
        weChatMessage.updateMessage("今天推送什么呢?");

        log.info("================================================");

        // 注销其中一个观察者
        weChatMessage.removeObserver(user2);

        // 模拟被观察者发生变化
        weChatMessage.updateMessage("今天天气不错呢!");

    }

}

运行结果日志记录如下

2023-07-28 10:23:21.663 INFO 34500 — [ main] d.b.example.design_patterns.gczms.User1 : 我是具体的观察者之一:User1
2023-07-28 10:23:21.664 INFO 34500 — [ main] d.b.example.design_patterns.gczms.User1 : 被观察者发生变化, 接收消息:今天推送什么呢?
2023-07-28 10:23:21.664 INFO 34500 — [ main] d.b.example.design_patterns.gczms.User2 : 我是具体的观察者之一:User2
2023-07-28 10:23:21.664 INFO 34500 — [ main] d.b.example.design_patterns.gczms.User2 : 被观察者发生变化, 接收消息:今天推送什么呢?
2023-07-28 10:23:21.664 INFO 34500 — [ main] d.b.example.design_patterns.gczms.User3 : 我是具体的观察者之一:User3
2023-07-28 10:23:21.664 INFO 34500 — [ main] d.b.example.design_patterns.gczms.User3 : 被观察者发生变化, 接收消息:今天推送什么呢?
2023-07-28 10:23:21.664 INFO 34500 — [ main] d.b.e.d.gczms.ObserverTest : ================================================
2023-07-28 10:23:21.669 INFO 34500 — [ main] d.b.example.design_patterns.gczms.User1 : 我是具体的观察者之一:User1
2023-07-28 10:23:21.671 INFO 34500 — [ main] d.b.example.design_patterns.gczms.User1 : 被观察者发生变化, 接收消息:今天天气不错呢!
2023-07-28 10:23:21.671 INFO 34500 — [ main] d.b.example.design_patterns.gczms.User3 : 我是具体的观察者之一:User3
2023-07-28 10:23:21.671 INFO 34500 — [ main] d.b.example.design_patterns.gczms.User3 : 被观察者发生变化, 接收消息:今天天气不错呢!文章来源地址https://www.toymoban.com/news/detail-617792.html

到了这里,关于java设计模式-观察者模式的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Java设计模式-观察者模式-SpringBoot实现

    项目:https://gitee.com/KakarottoChen/blog-code.git 的:JavaSpringListener Java观察者模式是一种设计模式,用于实现对象之间的一对多依赖关系。在观察者模式中,当一个对象的状态发生变化时,它的所有依赖对象(观察者)都会自动收到通知并进行相应的更新。 观察者模式由以下几个核

    2024年02月08日
    浏览(40)
  • java设计模式-观察者模式(jdk内置)

    上一篇我们学习了 观察者模式。 观察者和被观察者接口都是我们自己定义的,整个设计模式我们从无到有都是自己设计的,其实,java已经内置了这个设计模式,我们只需要定义实现类即可。 下面我们不多说明,直接示例代码,例子依然同 观察者模式篇章,建议先去看看。

    2024年02月15日
    浏览(36)
  • Java设计模式系列--观察者模式写法2:JDK

    原文网址:Java设计模式系列--观察者模式写法2:JDK_IT利刃出鞘的博客-CSDN博客 说明 本文用示例介绍观察者模式的一种写法:JDK。 JDK的观察者模式简介 在 Java 中,java.util.Observable 类和 java.util.Observer 接口定义了观察者模式,只要实现这两个接口就可以编写观察者模式。 1. Ob

    2024年02月13日
    浏览(39)
  • 【设计模式——学习笔记】23种设计模式——观察者模式Observer(原理讲解+应用场景介绍+案例介绍+Java代码实现)

    有一个天气预报项目,需求如下: 气象站可以将每天测量到的温度、湿度、气压等等以公告的形式发布出去(比如发布到自己的网站或第三方) 需要设计开放型API,便于其他第三方也能接入气象站获取数据 提供温度、气压、湿度的接口 测量数据更新时,要能实时的通知给第三

    2024年02月14日
    浏览(38)
  • 【设计模式】观察者模式

    观察者模式(又被称为发布-订阅(Publish/Subscribe)模式,属于行为型模式的一种,它定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象。这个主题对象在状态变化时,会通知所有的观察者对象,使他们能够自动更新自己。 Subject:抽象主题(被观察者

    2024年02月13日
    浏览(52)
  • 设计模式——观察者模式

    观察者模式可以分为观察者和被观察者,观察者通过注册到一个被观察者中,也可视为订阅,当被观察者的数据发生改变时,会通知到观察者,观察者可以据此做出反应。 可以类比订阅报纸,报社就是被观察者,订阅者就是观察者,订阅者通过订阅报纸与报社建立联系,而报

    2024年02月15日
    浏览(53)
  • 设计模式-观察者模式

    观察者模式是一种行为型设计模式,它定义了一种一对多的依赖关系,当一个对象的状态发生改变时,其所有依赖者都会收到通知并自动更新。当对象间存在一对多关系时,则使用观察者模式(Observer Pattern)。比如,当一个对象被修改时,则会自动通知依赖它的对象。观察者

    2024年02月15日
    浏览(58)
  • 设计模式---观察者模式

    1,概念         属于行为模式的一种,定义了一种一对多的依赖关系,让多个观察者对象同时监听某一对象主题对象,这个主题对象在状态变化时,会通知所有的观察者对象,使他们能够自动更新自己。 在观察者模式中有如下角色: Subject:抽象主题(抽象被观察者),

    2024年02月15日
    浏览(65)
  • 设计模式:观察者模式

    定义 观察者模式(Observer Pattern)是一种行为设计模式,允许一个对象(称为“主题”或“可观察对象”)维护一组依赖于它的对象(称为“观察者”),当主题的状态发生变化时,会自动通知所有观察者对象。 应用场景 观察者模式适用于以下场景: 联动反应 :当一个对象

    2024年04月08日
    浏览(59)
  • 重温设计模式 --- 观察者模式

    观察者模式 是一种行为型设计模式,它允许对象之间建立一种一对多的关系,使得当一个对象状态改变时,所有依赖它的对象都能够自动得到通知并更新自己的状态。该模式可以帮助我们实现松耦合的系统,以便更好地应对变化和扩展。 在观察者模式中,有两个角色: 观察

    2024年02月13日
    浏览(59)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包