springboot中应用观察者模式

最新推荐文章于 2024-06-28 16:07:08 发布
最新推荐文章于 2024-06-28 16:07:08 发布
阅读量2.1k 收藏 7
点赞数 1
分类专栏： Java基础 文章标签： 设计模式 spring spring boot java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40427212/article/details/107809231
版权

近几天在学习springboot源码时发现，在springboot项目启动过程中设置了很多监听器，发现监听器的原理和设计模式中的 观察者模式 很相似。故灵感来袭总结一下 springboot中应用观察者模式

观察者模式解决的问题是：当一个东西（后文称之为 前者）的状态发生改变时，一些与其关联的东西（后文称之为 后者）也会随之做出各自改变。传统的做法是前者在变化后需要直接遍历一个个的通知（调用）到后者，当以后有新的后者需要扩展时，前者的代码也需要改动，不利于扩展。观察者模式解决的问题是，利用java的多态特性，抽象前者与后者直接耦合，在代码层次，前者在改变时只需要发出通知即可，而不需要关心具体通知到谁，后者只需要在前者中注册即可。这样做方便了扩展，当以后有新的后者需要扩展时，直接新增就行了，不需要改动前者的代码。

具体实现demo：

       利用springboot和java的util包中定义的观察者与被观察者工具类实现

1，先定义被观察者

package com.kun.watcher.observed;

import com.kun.watcher.NotifyType;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.List;
import java.util.Observable;
import java.util.Observer;
import java.util.logging.Logger;

/**
 * 接口被观察者
 *
 * @author kun
 * @date 2020/08/04 15:27
 */
@Component
public class WebObserved extends Observable {

    private static final Logger LOG = Logger.getGlobal();

    @Autowired
    private List<Observer> observerList;

    @PostConstruct
    public void observerRegister() {
        LOG.info("注册观察者-->");
        observerList.forEach(this::addObserver);
    }

    public void useWeb() {
        try {
            LOG.info("开始调用web了");
            this.setChanged();
            this.notifyObservers();

            Thread.sleep(2000);
            LOG.info("web被调用了2秒了");
            this.setChanged();
            this.notifyObservers(NotifyType.KUN);

            Thread.sleep(2000);
            LOG.info("web被调用了4秒了");
            this.setChanged();
            this.notifyObservers(NotifyType.ZHANGSAN);

            Thread.sleep(2000);
            LOG.info("web被调用了6秒了");
            this.setChanged();
            this.notifyObservers(NotifyType.LISI);

            Thread.sleep(2000);
            LOG.info("web被调用结束");
            this.setChanged();
            this.notifyObservers();

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

继承Observable被观察者类，并使用@Component注解将我们自定义的被观察者类交给spring管理。注入所有观察者对象，

利用@PostConstruct注解，在此被观察者的bean初始化完成时调用方法，将所有观察者对象注册进Observable的列表

在自定义的方法useWeb()中在合适的时机发出通知（在调用notifyObservers()方法之前一定要先调用setChanged()方法，将状态置为改变，然后通知才会有效）

2，定义观察者

package com.kun.watcher.observer;

import com.kun.watcher.NotifyType;
import com.kun.watcher.observed.WebObserved;
import org.springframework.stereotype.Component;

import java.util.Observable;
import java.util.Observer;
import java.util.logging.Logger;

/**
 * 观察者昆
 *
 * @author kun
 * @date 2020/08/04 16:13
 */
@Component
public class KunObserver implements Observer {

    private static final Logger LOG = Logger.getGlobal();

    @Override
    public void update(Observable o, Object arg) {
        if (arg == null || (o instanceof WebObserved && NotifyType.KUN.toString().equals(((NotifyType) arg).name()))) {
            LOG.info("昆收到通知");
        }
    }
}


package com.kun.watcher.observer;

import com.kun.watcher.NotifyType;
import com.kun.watcher.observed.WebObserved;
import org.springframework.stereotype.Component;

import java.util.Observable;
import java.util.Observer;
import java.util.logging.Logger;

/**
 * 观察者张三
 *
 * @author kun
 * @date 2020/08/04 16:13
 */
@Component
public class ZhangsanObserver implements Observer {

    private static final Logger LOG = Logger.getGlobal();

    @Override
    public void update(Observable o, Object arg) {
        if (arg == null || (o instanceof WebObserved && NotifyType.ZHANGSAN.toString().equals(((NotifyType) arg).name()))) {
            LOG.info("张三收到通知");
        }
    }
}


package com.kun.watcher.observer;

import com.kun.watcher.NotifyType;
import com.kun.watcher.observed.WebObserved;
import org.springframework.stereotype.Component;

import java.util.Observable;
import java.util.Observer;
import java.util.logging.Logger;

/**
 * 观察者李四
 *
 * @author kun
 * @date 2020/08/04 16:13
 */
@Component
public class LisiObserver implements Observer {

    private static final Logger LOG = Logger.getGlobal();

    @Override
    public void update(Observable o, Object arg) {
        if (arg == null || (o instanceof WebObserved && NotifyType.LISI.toString().equals(((NotifyType) arg).name()))) {
            LOG.info("李四收到通知");
        }
    }
}


package com.kun.watcher.observer;

import com.kun.watcher.NotifyType;
import com.kun.watcher.observed.WebObserved;
import org.springframework.stereotype.Component;

import java.util.Observable;
import java.util.Observer;
import java.util.logging.Logger;

/**
 * 观察者王二麻子
 *
 * @author kun
 * @date 2020/08/04 16:13
 */
@Component
public class WangermaziObserver implements Observer {

    private static final Logger LOG = Logger.getGlobal();

    @Override
    public void update(Observable o, Object arg) {
        if (arg == null || (o instanceof WebObserved && NotifyType.WANGERMAZI.toString().equals(((NotifyType) arg).name()))) {
            LOG.info("王二麻子收到通知");
        }
    }
}

定义了几个观察者，实现Observer观察者接口，并交给spring容器，这样就可以实现自动注册。

3，定义一个controller，前端发送http请求，改变了被观察者的状态，通知所有观察者。

package com.kun.watcher.controller;

import com.kun.watcher.observed.WebObserved;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * 接口
 *
 * @author kun
 * @date 2020/08/04 15:24
 */
@Controller
public class Web {

    @Autowired
    private WebObserved webObserved;

    @GetMapping("/b")
    @ResponseBody
    public String getBegin(){
        webObserved.useWeb();
        return "success";
    }
}

启动，发送请求，结果如下：

2020-08-05 11:12:28.908  INFO 2116 --- [nio-8001-exec-1] global  : 开始调用web了
2020-08-05 11:12:28.908  INFO 2116 --- [nio-8001-exec-1] global  : 张三收到通知
2020-08-05 11:12:28.908  INFO 2116 --- [nio-8001-exec-1] global  : 王二麻子收到通知
2020-08-05 11:12:28.908  INFO 2116 --- [nio-8001-exec-1] global  : 李四收到通知
2020-08-05 11:12:28.908  INFO 2116 --- [nio-8001-exec-1] global  : 昆收到通知
2020-08-05 11:12:30.910  INFO 2116 --- [nio-8001-exec-1] global  : web被调用了2秒了
2020-08-05 11:12:30.910  INFO 2116 --- [nio-8001-exec-1] global  : 昆收到通知
2020-08-05 11:12:32.911  INFO 2116 --- [nio-8001-exec-1] global  : web被调用了4秒了
2020-08-05 11:12:32.911  INFO 2116 --- [nio-8001-exec-1] global  : 张三收到通知
2020-08-05 11:12:34.911  INFO 2116 --- [nio-8001-exec-1] global  : web被调用了6秒了
2020-08-05 11:12:34.911  INFO 2116 --- [nio-8001-exec-1] global  : 李四收到通知
2020-08-05 11:12:36.912  INFO 2116 --- [nio-8001-exec-1] global  : web被调用结束
2020-08-05 11:12:36.912  INFO 2116 --- [nio-8001-exec-1] global  : 张三收到通知
2020-08-05 11:12:36.912  INFO 2116 --- [nio-8001-exec-1] global  : 王二麻子收到通知
2020-08-05 11:12:36.912  INFO 2116 --- [nio-8001-exec-1] global  : 李四收到通知
2020-08-05 11:12:36.913  INFO 2116 --- [nio-8001-exec-1] global  : 昆收到通知

若要扩展观察者，仅需要实现Observer接口，并加上@Component注解即可

昆虫520
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
【设计模式】Spring Boot中实践观察者模式
hello_zxx的博客
10-29 735
观察者模式(Observer Pattern)在spring boot中的实践方法
springboot实现设计模式- 观察者模式
Faylinn的博客
05-27 6899
观察者模式可用于订阅发布类似场景之类使用 当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知它的依赖对象。观察者模式属于行为型模式。 介绍 意图：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。 主要解决：一个对象状态改变给其他对象通知的问题，而且要考虑到易用和低...
设计模式（3）观察者模式——简介和SpringBoot应用
最新发布
weixin_45873793的博客
06-28 403
观察者模式（Observer Pattern）是一种行为设计模式，又称为发布/订阅(Publish/Subscribe)模式，它定义了对象间的一种一对多的依赖关系，使得当一个对象状态改变时，它的所有依赖对象都会被自动通知并且更新。短信Service实现ApplicationListener接口。举例：用户注册之后发送短信通知、积分还有优惠券。2. SpringBoot观察者模式。优惠券Service直接在。1. 观察者模式简介。观察者模式的使用场景。
【Java后端开发】SpringBoot使用观察者模式
枯木何日可逢春
07-21 454
SpringBoot使用观察者模式
springBoot 观察者模式
qq_41972358的博客
07-08 1488
springBoot 观察者模式
【无标题】
qq_38377126的博客
12-17 229
springboot项目中应用-观察者模式 观察者模式 当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知依赖它的对象。观察者模式属于行为型模式。 介绍 意图：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。 主要解决：一个对象状态改变给其他对象通知的问题，而且要考虑到易用和低耦合，保证高度的协作。 何时使用：一个对象（目标对象）的状态发生改变，所有的依赖对象（观察者对象）
SpringBoot中实现简单观察者模式
weixin_45061591的博客
03-09 684
观察者模式：当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。 比如，当一个对象被修改时，则会自动通知依赖它的对象。观察者模式属于行为型模式 。 观察者模式是发布订阅模式的一种特殊实现，发布订阅模式是在观察者模式的基础上做的优化升级。
java观察者模式观察者模式
05-06
观察者模式是设计模式中的一种行为模式，它在Java编程中有着广泛的应用。该模式的主要目的是定义对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。这种模式也被...
观察者模式图和代码实现
03-16
这些工具通常提供更高级的功能，如异步通知、事件过滤等，可以帮助我们更好地应用观察者模式。 总的来说，观察者模式是一种强大的设计模式，能够有效地处理对象之间的交互和通信，是软件工程中不可或缺的一部分。...
springboot+rabbitmq
03-21
本项目结合了这两个技术，提供了队列（Queue）、主题（Topic）和广播（Fanout）模式的示例，帮助学习者理解如何在Spring Boot应用中集成并使用RabbitMQ进行消息传递。 首先，让我们深入了解一下Spring Boot。Spring...
SpringBoot+EventBus使用教程示例代码
11-11
在本文中，我们将深入探讨如何在SpringBoot应用中使用EventBus，这是一个基于Guava库的事件总线系统。EventBus的引入使得松耦合的组件间通信变得更加简单和高效。让我们一起通过步骤来理解这个“SpringBoot+EventBus...
SpringBoot-DesignMode-master.zip
09-28
Spring事件驱动模型基于观察者模式，当事件发生时，所有订阅者都会收到通知。 二十、状态模式(State Pattern) Spring的状态机（StatePattern）支持状态转换，根据对象状态改变其行为。 二十一、策略模式(Strategy ...
基于Springboot的观察者模式实现
Wax_Gourd258的博客
10-21 300
观察者模式实践基于Springboot的观察者模式实现抽象层实现测试结果 基于Springboot的观察者模式实现 业务上很多地方可以用到观察者模式，于是写了个通用的模板，实现如下： 抽象层 /** * @Author * @Description 观察者 * @CreateTime 2021年10月21日 09:22:00 */ public interface Observer { @Async void notify(Field field, Object oldVal, O
观察者模式笔记，spring boot中应用
qq_19445279的博客
03-02 186
什么是观察者模式 1.观察者模式也叫做发布–订阅模式（Publish/Subscribe），从名字出发可以看出是一种一对多的依赖关系，观察者有多个，多个观察者同时监听某一个主题，这个主题状态发生时会通知所有的观察者去更新状态代码结构图如图所示： 2.从图中可以看出在subject中持有observe类的应用，subject发出相关的通知后会在观察者中发生相关的动做。 在spring boot中 的应用 上图中有一个明显的不足就是发布者与订阅者之间存在的耦合关系，现实中发布者与订阅者之间根本就不知道彼此的存
Springboot项目实现简单的观察者模式
hanzi552200的博客
04-16 246
最近在写项目的消息通知推送，本来一开始只有服务号的模板推送，后面发现很多人没有关注服务号，因此新增了一个小程序的订阅消息推送，这个不用关注，但是只能用户主动订阅的时候才能推送，而且目前只能推送一次性的。然后就开造，后面发现代码贼乱，耦合性又太强了，于是乎在想能不能使用设计模式来解决，最终经过多轮搜索+chatgpt，就使用观察者模式开造啦。
Spring Boot Event 观察者模式，轻松实现业务解耦
ZDY0904的博客
12-23 112
Spring Boot Event 观察者模式，轻松实现业务解耦
Spring Boot Event 观察者模式，轻松带你实现业务解耦！
emprere的博客
07-27 99
点击关注公众号：互联网架构师，后台回复2T获取2TB学习资源！上一篇：Alibaba开源内网高并发编程手册.pdf写在最前实际业务开发过程中，业务逻辑可能非常复杂，核心业务 + N个子业务。如果都放到一块儿去做，代码可能会很长，耦合度不断攀升，维护起来也麻烦，甚至头疼。还有一些业务场景不需要在一次请求中同步完成，比如邮件发送、短信发送等。MQ 确实可以解决这个问题，但 ...
Spring中的观察者模式（发布订阅模式）（基于SpringBoot实现）
Shadow_132141的博客
08-21 1892
概述： 　　spring中的事件机制涉及到者几个类文件 ：ApplicationEvent(事件类型)、ApplicationListener（事件监听类）、ApplicationEventPublisher（事件发布类）。 　　ApplicationEvent：继承jdk Utill包中的 EventObject。 　　ApplicationListener ：接口继承了util...
springboot笔记④——观察者设计模式（含jdk和spring实现的）
ww0peo的博客
12-01 662
自己实现的观察者模式 观察者模式 被观察者拥有观察者的应用 被观察者主动通知观察者 监听事件 监听对象 jdk的观察者模式 Observable 类 继承被观察者 Observer 接口 实现观察者 松耦合 可以快速取消监听 spring中的观察者模式 spring中的事件ApplicationEvent，有两个重要的子类 ApplicationContextEvent，与应用程序上下文相关，它同...
如何使用SpringBoot提供的观察者模式
05-20
在Spring Boot中，可以使用Java中内置的观察者模式来实现事件驱动的编程。具体步骤如下： 1. 定义观察者接口：通常情况下，观察者接口包含一个update()方法，用于接收事件通知。 ```java public interface Observer { void update(); } ``` 2. 定义事件类：通常情况下，事件类包含事件类型和事件数据。 ```java public class Event { private EventType eventType; private Object eventData; // getters and setters } ``` 3. 定义事件类型枚举类：用于区分不同的事件类型。 ```java public enum EventType { EVENT_TYPE_1, EVENT_TYPE_2 // ... } ``` 4. 定义观察者实现类：实现Observer接口，并在update()方法中处理事件。 ```java public class MyObserver implements Observer { @Override public void update() { // 处理事件 } } ``` 5. 定义事件发布类：用于发布事件。 ```java @Component public class EventPublisher { @Autowired private List<Observer> observers; public void publish(Event event) { for (Observer observer : observers) { observer.update(event); } } } ``` 6. 在需要监听事件的地方注册观察者：使用@Autowired注入EventPublisher，并调用其publish()方法发布事件。 ```java @Component public class MyService implements Observer { @Autowired private EventPublisher eventPublisher; @PostConstruct public void init() { eventPublisher.register(this); } @Override public void update(Event event) { // 处理事件 } } ``` 以上就是使用Spring Boot提供的观察者模式的基本步骤。需要注意的是，观察者模式适用于一对多的场景，即一个事件可以被多个观察者接收和处理。在实际应用中，也可以根据具体的业务需求进行扩展和改进。
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值