监听器设计模式

最新推荐文章于 2024-05-28 10:18:58 发布
最新推荐文章于 2024-05-28 10:18:58 发布
阅读量6.8k 收藏 20
点赞数 10
文章标签： Java 设计模式 监听器设计模式 观察者设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gsjwxhn/article/details/90601466
版权

监听器设计模式

设计模式

设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。

创建型

通过特定的方式创建特定对象的设计模式

（工厂方法模式，抽象工厂模式，单例模式，建造者模式，原型模式）

结构型

为了解决某一特定问题所搭建的特定代码结构的设计模式

（适配器模式，装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式）

行为型

通过构建不同的角色来完成某一特定功能的设计模式

(策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式)

通过了解以上我们知道设计模式的大概 接下来进入重点 监听器设计模式，监听器设计模式是观察者设计模式的衍生，所以得先了解观察者设计模式。

观察者设计模式

观察者设计模式从名字上来看，首先得有观察者和被观察者，所以它有两个接口：IObserve和IObservable，其主要实现的功能就是当被观察者对象的状态有更改的时候，观察者时时会有相应的通知并做出相应的操作
原理：就是在目标对象中耦合观察者的对象，并且在注册观察者对象的时候调用相应操作的方法； 两者之间的关系是单向关联的；目标类和观察类之间维护的是松耦合的关系；
在这里插入图片描述

观察者接口（IObserve）

需要实现的功能

  1. 接收并处理被观察者发送来的信息
package IObserve;
public interface IObserve {
//    观察者处理被观察者发送过来额信息
    void handleNotify(String message);
}

观察者实现类（FirstObserve、SecondObserve）

有多个观察者，所以需要写多个实现类，第一个观察者

package IObserve;
public class FistObserve implements IObserve {
    @Override
    public void handleNotify(String message) {
        System.out.println("1号接受的消息"+message );
    }
}

第二个观察者

package IObserve;
public class SecondObserve implements IObserve {
    @Override
    public void handleNotify(String message) {
        System.out.println("2号接受的消息"+message);
    }
}

被观察者接口（IObservable）

需要实现的功能

  1. 可以添加观察者
    添加操作可以通过Array List的add()方法实现。
  2. 删除观察者
    删除操作通过ArrayList的remove()方法实现。
  3. 向观察者发送信息
package IObservable;
import IObserve.IObserve;

public interface IObservable {
//    添加观察者
    void addObserve(IObserve observable);
//    删除观察者
    void removeObserve(IObserve observable);
//    向观察者发送信息
    void notifyObservers(String message);
}

被观察者实现类

由于一个被观察者可以有多个观察者，所以可以创建一个ArrayList来存放多个观察者。

package IObservable;
import IObserve.IObserve;
import java.util.ArrayList;
import java.util.List;

public class Some implements IObservable{
//    由于一个被观察者可以被多个观察者所观察，所以要设置一个观察者链表里
    private List<IObserve> observes;
    public Some(){
        //在被观察者对象被创建时，就将集合创建
        observes = new ArrayList<>();
    }
    @Override
    public void addObserve(IObserve observe) {
        observes.add(observe);
    }
    @Override
    public void removeObserve(IObserve observe) {
        observes.remove(observe);
    }
    @Override
    public void notifyObservers(String message) {
        for (IObserve observe :
                observes) {
            observe.handleNotify(message);
        }
    }
}

测试类

首先需要创建观察者类的对象，然后创建被观察者类的对象，因为在被观察者类中写入的构造方法中有ArrayList的创建，所以在创建其对象的时候就已经准备好一个链表observes来存放观察者的对象observe，被观察者类Some其对象调用notifyObservers()方法，向观察者发送信息，最后通过遍历observes来调用观察者实现类的handleNotify(message)方法来实现观察者实现的操作。

package test;

import IObservable.Some;
import IObserve.SecondObserve;
import IObserve.FistObserve;
import IObserve.IObserve;

public class Test {
    public static void main(String[] args) {
        //创建多个观察者
        IObserve iObserve1 = new FistObserve();
        IObserve iObserve2 = new SecondObserve();
        //创建被观察者
        Some some =new Some();
        //被观察者添加观察者
        some.addObserve(iObserve1);
        some.addObserve(iObserve2);
        //被观察者向观察者发送信息
        some.notifyObservers("GOGOGOGOGOGO");
        //删除观察者后
        some.removeObserve(iObserve1);
        some.notifyObservers("GO ");
    }
}

这样就会实现，只有被观察者有动态变化，观察者就会有所反应。
在这里插入图片描述

监听器设计模式

监听器设计模式是观察者设计模式的一种实现。他与观察者设计模式不同点有

  1. 一个被观察者只能有一个观察者对象，而不是多个
  2. 被监听者（事件源）的状态改变，被定义为一个对象，称为事件，而不是字符串
  • 监听器（监听者）
    负责监听发生在事件源上的事件
  • 事件源（被监听对象，产生事件的对象）
    提供订阅与取消监听者的方法，并负责维护监听者列表，发送事件给监听者
  • 事件处理器
    监听器的成员方法，当时事件发生后会触发对应的处理器（成员方法）。

一般情况下，监听器对象被事件触发后，都是需要从事件中获取到事件源对象，然后再从事件源中获取一些数据。也就是说，在事件对象中一般需要提供获取事件源对象的方法，当然，除了获取事件源方法外，根据业务需求，事件对象一般还需要提供一些其他的数据，以便让监听器获取。

监听器在进行工作时，可以分为以下步骤

  1. 将监听器绑定到事件源（注册监听器）
  2. 事件发生后触发监听器的成员方法，即事件处理器，传递事件对象
  3. 事件处理器通过事件对象获得事件源，并对事件源进行处理。

在这里插入图片描述

事件接口（ICurdEvent）

package event;
//定义增删改查事件
//C: Create
//U: Update
//R: Retrieve
//D: Delete
//通常对于事件对象，我们一般需要从事件对象中获取到事件源对象
public interface ICurdEvent{
    //声明事件类型
    String Create_EVENT = "create event";
    String Update_EVENT = "update event";
    String Retrieve_EVENT = "retrieve event";
    String Delete_EVENT = "delete event";
    //获取事件源对象
    IListenerable getEventSource();
    //获取事件类型
    String getEventType();

}

事件实现类

package implement;
import event.ICurdEvent;
import event.IListenerable;

public class CurdEvent implements ICurdEvent {
    private IListenerable eventSource;  //事件源
    private String methodname;          //事件源所执行的方法名称
    public CurdEvent(IListenerable eventSource,String methodname){
        super();
        this.eventSource = eventSource;
        this.methodname = methodname;
    }
    @Override
    public IListenerable getEventSource() {
        return eventSource;
    }
    //根据事件源所执行的不同的方法返回不同的事件类型
    @Override
    public String getEventType() {
        String eventType = null;
        if (methodname.startsWith("save")){
            eventType = Create_EVENT;
        }else if (methodname.startsWith("remove")){
            eventType = Delete_EVENT;
        }else if (methodname.startsWith("modify")){//修改
            eventType = Update_EVENT;
        }else if (methodname.startsWith("find")){
            eventType = Retrieve_EVENT;
        }else {
            eventType = "have not this event type";
        }
        return eventType;
    }
}

监听器接口（IListener）

package event;
//监听器接口（观察者）
//作用：处理消息（事件）
public interface IListener {
    void handle(ICurdEvent event);
}

监听器实现类

package implement;

import event.ICurdEvent;
import event.IListener;
//定义监听器类
public class Listener implements IListener {
    @Override
    public void handle(ICurdEvent event) {
        String eventType = event.getEventType();
        if (ICurdEvent.Create_EVENT.equals(eventType)){
            System.out.println("添加操作");
        }else if (ICurdEvent.Delete_EVENT.equals(eventType)){
            System.out.println("删除操作");
        }else if (ICurdEvent.Update_EVENT.equals(eventType)){
            System.out.println("修改操作");
        }else if (ICurdEvent.Retrieve_EVENT.equals(eventType)){
            System.out.println("查找操作");
        }
    }
}

事件源接口（IListenerable）

package event;
//事件源接口（被观察者）
public interface IListenerable {
    //为事件源注册监听器
    void setListener(IListener listener);
    //触发监听器
    void triggerListener(ICurdEvent event);
}

事件源实现类

package implement;

import event.ICurdEvent;
import event.IListener;
import event.IListenerable;

//事件源类
public class Some implements IListenerable {
    private IListener listener;
    //注册监听器
    @Override
    public void setListener(IListener listener) {
        this.listener = listener;
    }
    //触发监听器
    @Override
    public void triggerListener(ICurdEvent event) {
        listener.handle(event);
    }
    public void saveStudent(){
        System.out.println("插入了一条数据");
        ICurdEvent event = new CurdEvent(this,"saveStudent");
        this.triggerListener(event);
    }
    public void removeStudent(){
        System.out.println("删除了一条数据");
        ICurdEvent event = new CurdEvent(this,"removeStudent");
        this.triggerListener(event);
    }
    public void modifyStudent(){
        System.out.println("修改了一条数据");
        ICurdEvent event = new CurdEvent(this,"modifyStudent");
        this.triggerListener(event);
    }
    public void findStudent(){
        System.out.println("插入了一条数据");
        ICurdEvent event = new CurdEvent(this,"findStudent");
        this.triggerListener(event);
    }
}

测试类

package test;
import event.IListener;
import implement.Listener;
import implement.Some;

public class Test {
    public static void main(String[] args) {
        //定义监听器
        IListener listener = new Listener();
        //定义事件源
        Some some = new Some();
        //事件源注册监听器
        some.setListener(listener);
        some.saveStudent();
        some.removeStudent();
    }
}

在这里插入图片描述

Wiki~
关注
  • 10
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
C# IObservable与IObserver通知机制 观察者模式（推式模型）
深南大道
02-04 885
using System; using System.Collections.Generic; using System.Linq; using System.Threading; using System.Threading.Tasks; namespace ConsoleApp1 { class Program { static void Main(string[] args) { /* C# I.
Java设计模式之监听器模式实例详解
08-28
主要介绍了Java设计模式之监听器模式,结合实例形式较为详细的分析了java设计模式中监听器模式的概念、原理及相关实现与使用技巧,需要的朋友可以参考下
java设计模式--观察者模式和事件监听器模式
热门推荐
温水青蛙
04-08 5万+
监听器模式：事件源经过事件的封装传给监听器，当事件源触发事件后，监听器接收到事件对象可以回调事件的方法 观察者模式：观察者(Observer)相当于事件监听者，被观察者(Observable)相当于事件源和事件，执行逻辑时通知observer即可触发oberver的update,同时可传被观察者和参数 监听器模式demo 1、首要定义事件源对象（事件源相当于单击按钮事件当中的按钮对象
观察者模式Observer
zxf347085420的博客
05-28 668
例子：基于同一组数据，生成了很多不同的界面来显示，有曲线图显示方式，有圆饼图显示方式，有柱状图显示方式等等…，当底层数据发生改变时，所有基于同一组数据的图像显示都需要修改图像，那么此时有两种实现方式所有图形界面模块都去观察底层数据是否做了改变，如果变化，那么读取数据，修改图像显示。
设计模式——监听器模式
meser88的博客
08-23 603
import lombok.extern.slf4j.Slf4j; import javax.annotation.Resource; @Slf4j public class BaseProcess { // 具体方法根据业务逻辑而定 @Resource private BusinessService businessService; protected void process(MultiMsg multiMsg) { businessServic.
设计模式之观察者模式相关、监听器模式
wang_luwei的博客
06-15 1586
观察者模式：定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象，这个主题对象的状态发生变化时，会通知所有观察者对象，使它们能够自己更新自己。（在对象之间定义了一对多的依赖，这样一来，当一个对象改变状态，依赖它的对象会收到通知并自动更新） 观察者模式结构图：Subject类，可以翻译为主题或者抽象通知者，一般用一个抽象类或者一个接口实现。它把所有对观察者对象的引用保存在一个聚集里，每个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以增加、删除观察者对象 以及通知聚集里面的观察者。Con
设计模式之监听模式
山阴少年
04-11 1105
本文将会介绍设计模式中的监听模式。
为IObservable实现自己的运算符
技术专栏
03-06 668
您可以通过为LINQ库不提供的操作添加新运算符，或者通过创建自己的标准查询运算符实现来提高可读性和性能，从而扩展Rx。 编写自定义版本的标准LINQ操作符在您希望使用内存中对象操作时以及当预期自定义不需要查询的全面视图时非常有用。创建新操作符　　 　　LINQ提供了一整套操作符，涵盖了一组实体上的大多数可能的操作。 但是，您可能需要一个运算符为查询添加特定的语义，尤其是如果您可以在代码中多次重复使
设计模式实验报告.rar
06-15
在IT行业中，设计模式是软件开发中的重要概念，它们代表了在特定情境下解决常见问题的最佳实践。本实验报告深入探讨了多种经典的设计模式，并通过实际的代码实现、UML类图以及运行截图来帮助理解这些模式的核心理念...
设计模式入门——胡老师的监听器模式
03-29
NULL 博文链接：https://coco-young.iteye.com/blog/1275485
buildType设计模式课程设计
最新发布
06-20
在IT行业中，设计模式是一种被广泛认可的解决软件设计问题的最佳实践。它们是经验丰富的开发者在面对特定设计问题时，经过反复验证后形成的通用解决方案模板。在这个“buildType设计模式课程设计”项目中，我们可以...
设计模式 java 参考模式
07-02
9. Google Guava中的设计模式：开源库Guava在实现过程中广泛运用了设计模式，例如工厂模式、单例模式、装饰器模式等，学习Guava的源码可以帮助理解如何在实际项目中有效应用设计模式。 10. 面向对象的基础理论：...
java监听设计模式（java观察者设计模式）
qq_43934844的博客
01-01 650
在此种模式中，一个目标物件管理所有相依于它的观察者物件，并且在它本身的状态改变时主动发出通知。观察者（屏幕相应对象、响铃相应对象、震动相应对象等），这些观察者就是订阅了call的状态，当call的状态变成来电时，这些观察者就能收到相应的信息，然后做一些更新的操作。在上述例子中，如果不使用观察者设计模式，要怎么设计比较合理，任何一种设计模式的出现都有它使用的场景，这都是历经多少前辈的经验总结出来的，观察者设计模式也不例外。1、 对一个对象状态的更新，需要其他对象同步更新，而且其他对象的数量动态可变。
设计模式之观察者模式（监听模式）
RichardGeek的博客
06-20 3646
观察者模式
设计模式之监听器模式
bigbearxyz的博客
04-16 2182
监听器模式，主要由3个角色组成：事件（EventObject），监听器（EventListener），事件发布者（EventPublish）。 其核心流程便是，由事件发布者发布事件，在事件发布前后分别放置监听器。 其代码示例如下： 1.事件 public class MethodExecutionEvent extends EventObject { private static final long serialVersionUID = -71960369269303337L;
设计模式：观察者模式（二）——C#内置接口实现观察者模式
deqiuzong8701的博客
08-18 357
通过C#的内置观察者接口实现观察者模式 1. 接口介绍 C#内部提供了IObservable和IObserver两个泛型接口，IObservable是可观察的，就是主题（Subject）要实现的接口，IObserver就是观察者需要实现的接口，接口定义如下： //T:提供通知信息的对象。 public interface IObservable<out T> { //...
C# 观察者模式
wangnaisheng的专栏
03-13 882
C# 观察者模式
设计模式系列-监听模式
写代码的大胖
09-03 563
先说点什么 设计模式以前也看过，但大都走马观花。最近也是巧，发现了一本书 《人人都懂设计模式》，简单翻了几页，觉得我能开心的读进去，并且我也觉得我到了可以思考设计模式的时候了。在以前，经验比较少，一些场景没接触过，也没法感同身受的思考为什么要这么设计？有时候明明把代码弄得层次多了更复杂了，读起来也麻烦了。为什么还要搞这么个东西呢？随着经验的增多，更多的理解了折中取舍，为了系统的稳定，为了将来开发的更舒爽，一些初期的痛也是要承受的。所以，开始了 设计模式。Let’s do it。 什么是监听模式 Defin
Java监听器模式在实际中的应用
xuanzui的博客
03-25 483
监听器模式是一种行为型设计模式，它允许对象之间通过监听和触发事件的方式实现解耦，提高代码的灵活性和可维护性。当事件源触发事件时，所有注册了对应类型监听器的对象都会得到通知，然后执行相应的操作。注册监听器的方法通常接受实现了监听器接口的对象作为参数，并将其添加到一个监听器列表中。：当特定的事件发生时（例如，用户点击了一个按钮，或者某个数据发生了变化），事件源将遍历其监听器列表，并调用每个监听器的相应方法。：在你的代码中，你需要创建一个或多个监听器对象，并使用事件源提供的注册方法将它们注册到事件源上。
JavaWeb开发：理解并实践监听器设计模式
监听器设计模式属于行为型，它关注的是对象之间的交互，通过角色之间的行为协作来实现特定功能。观察者模式的核心是定义了两个角色：被观察者和观察者。被观察者（如Servlet）有状态变化时，通过事件机制通知所有...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值