设计模式-观察者模式

已于 2022-05-22 11:53:30 修改
阅读量99 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式 观察者模式
于 2022-05-22 11:51:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33816292/article/details/124908652
版权

观察者模式观察者模式( Observer Pattern),又叫发布-订阅( Publish/ Subscribe)模式、模型-视图( Model/View)模式、源/监听器( Source/ ( Listener)模式或从属者( Dependents)模式。定义种一对多的依赖关系,一个主题对象可被多个观察者对象同时监听,使得每当主题对象状态变化时,所有依赖于它的对象都会得到通知并被自动更新。属于行为型模式。

观察者模式的核心是将观察者与被观察者解耦,以类似于消息/∫广播发送的机制联动两者,使被观察者的变动能通知到感兴趣的观察者们,从而做出相应的响应。

使用观察者模式设计鼠标事件响应API:

package com.lx.designPattern.observerpattern.mouseevent.core;

import java.lang.reflect.Method;

/**
 * @program: People
 * @description: 被观察者事件
 * @author: liu wei ping
 * @create: 2022-05-22 10:59
 */
public class Event {

    //事件源，动作是由谁发出的
    private Object source;
    //事件出发，要通知谁（观察者）
    private EventListener target;
    //观察者给的回应
    private Method callback;
    //事件的名称
    private String trigger;
    //事件的出发时间
    private long  time;

    public Event(EventListener target, Method callback) {
        this.target = target;
        this.callback = callback;
    }

    public Object getSource() {
        return source;
    }

    public Event setSource(Object source) {
        this.source = source;
        return this;
    }

    public EventListener getTarget() {
        return target;
    }

    public Event setTarget(EventListener target) {
        this.target = target;
        return this;
    }

    public Method getCallback() {
        return callback;
    }

    public Event setCallback(Method callback) {
        this.callback = callback;
        return this;
    }

    public String getTrigger() {
        return trigger;
    }

    public Event setTrigger(String trigger) {
        this.trigger = trigger;
        return this;
    }

    public long getTime() {
        return time;
    }

    public Event setTime(long time) {
        this.time = time;
        return this;
    }

    @Override
    public String toString() {
        return "Event{" +
                "source=" + source +
                ", target=" + target +
                ", callback=" + callback +
                ", trigger='" + trigger + '\'' +
                ", time=" + time +
                '}';
    }
}


package com.lx.designPattern.observerpattern.mouseevent.core;

import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

/**
 * @program: People
 * @description: 事件内容 被观察者的抽象
 * @author: liu wei ping
 * @create: 2022-05-22 11:00
 */
public class EventContext {
    protected Map<String, Event> events = new HashMap<String, Event>();

    public void addListener(String eventType, EventListener target, Method callback) {
        events.put(eventType, new Event(target, callback));
    }

    public void addListener(String eventType, EventListener target) {
        try {
            this.addListener(eventType, target, target.getClass().getMethod("on" + toUpperFirstCase(eventType),Event.class));
        } catch (NoSuchMethodException e) {
            return;
        }
    }

    //首字符转大写
    private String toUpperFirstCase(String eventType) {
        char[] chars = eventType.toCharArray();
        chars[0] -= 32;
        return String.valueOf(chars);
    }

    private void trigger(Event event) {
        event.setSource(this);
        event.setTime(System.currentTimeMillis());
        try {
            if (event.getCallback() != null) {
                //用反射调用回调函数
                event.getCallback().invoke(event.getTarget(), event);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    protected void trigger(String trigger) {
        if (!this.events.containsKey(trigger)) {
            return;
        }
        trigger(this.events.get(trigger).setTrigger(trigger));
    }


}


package com.lx.designPattern.observerpattern.mouseevent.core;

/**
 * @program: People
 * @description: 观察者
 * @author: liu wei ping
 * @create: 2022-05-22 11:00
 */
public interface EventListener {

}
package com.lx.designPattern.observerpattern.mouseevent.handler;

import com.lx.designPattern.observerpattern.mouseevent.core.EventContext;

/**
 * @program: People
 * @description: 鼠标单击
 * @author: liu wei ping
 * @create: 2022-05-22 11:01
 */
public class Mouse extends EventContext {

    public void click(){
        System.out.println("调用单击方法");
        this.trigger(MouseEventType.ON_CLICK);
    }

    public void doubleClick(){
        System.out.println("调用双击方法");
        this.trigger(MouseEventType.ON_DOUBLE_CLICK);
    }

    public void up(){
        System.out.println("调用弹起方法");
        this.trigger(MouseEventType.ON_UP);
    }

    public void down(){
        System.out.println("调用按下方法");
        this.trigger(MouseEventType.ON_DOWN);
    }

    public void move(){
        System.out.println("调用移动方法");
        this.trigger(MouseEventType.ON_MOVE);
    }

    public void wheel(){
        System.out.println("调用滚动方法");
        this.trigger(MouseEventType.ON_WHEEL);
    }

    public void over(){
        System.out.println("调用悬停方法");
        this.trigger(MouseEventType.ON_OVER);
    }

    public void blur(){
        System.out.println("调用获焦方法");
        this.trigger(MouseEventType.ON_BLUR);
    }

    public void focus(){
        System.out.println("调用失焦方法");
        this.trigger(MouseEventType.ON_FOCUS);
    }

}

package com.lx.designPattern.observerpattern.mouseevent.handler;

import com.lx.designPattern.observerpattern.mouseevent.core.Event;
import com.lx.designPattern.observerpattern.mouseevent.core.EventListener;

/**
 * @program: People
 * @description: 鼠标事件观察者
 * @author: liu wei ping
 * @create: 2022-05-22 11:02
 */
public class MouseEventListener implements EventListener {

    public void onClick(Event e){
        System.out.println("===========触发鼠标单击事件==========" + "\n" + e);
    }

    public void onDoubleClick(Event e){
        System.out.println("===========触发鼠标双击事件==========" + "\n" + e);
    }

    public void onUp(Event e){
        System.out.println("===========触发鼠标弹起事件==========" + "\n" + e);
    }

    public void onDown(Event e){
        System.out.println("===========触发鼠标按下事件==========" + "\n" + e);
    }

    public void onMove(Event e){
        System.out.println("===========触发鼠标移动事件==========" + "\n" + e);
    }

    public void onWheel(Event e){
        System.out.println("===========触发鼠标滚动事件==========" + "\n" + e);
    }

    public void onOver(Event e){
        System.out.println("===========触发鼠标悬停事件==========" + "\n" + e);
    }

    public void onBlur(Event e){
        System.out.println("===========触发鼠标失焦事件==========" + "\n" + e);
    }

    public void onFocus(Event e){
        System.out.println("===========触发鼠标获焦事件==========" + "\n" + e);
    }
}
package com.lx.designPattern.observerpattern.mouseevent.handler;

/**
 * @program: People
 * @description: 鼠标事件类型
 * @author: liu wei ping
 * @create: 2022-05-22 11:02
 */
public interface MouseEventType {
    //单击
    String ON_CLICK = "click";

    //双击
    String ON_DOUBLE_CLICK = "doubleClick";

    //弹起
    String  ON_UP = "up";

    //按下
    String  ON_DOWN = "down";

    //移动
    String  ON_MOVE = "move";

    //滚动
    String ON_WHEEL = "wheel";

    //悬停
    String ON_OVER = "over";

    //失焦
    String ON_BLUR = "blur";

    //获焦
    String ON_FOCUS = "focus";

}
package com.lx.designPattern.observerpattern.mouseevent;

import com.lx.designPattern.observerpattern.mouseevent.core.EventListener;
import com.lx.designPattern.observerpattern.mouseevent.handler.Mouse;
import com.lx.designPattern.observerpattern.mouseevent.handler.MouseEventListener;
import com.lx.designPattern.observerpattern.mouseevent.handler.MouseEventType;

/**
 * @program: People
 * @description: 观察者测试类
 * @author: liu wei ping
 * @create: 2022-05-22 11:30
 */
public class Test {
    public static void main(String[] args) {
        EventListener listener = new MouseEventListener();

        Mouse mouse = new Mouse();
        mouse.addListener(MouseEventType.ON_CLICK,listener);
        mouse.addListener(MouseEventType.ON_MOVE,listener);

        mouse.click();
        mouse.move();
    }

}

观察者测试类测试效果如下图：

观察者模式的优缺点

优点:

1、观察者和被观察者是松耦合(抽象耦合)的,符合依赖倒置原则

2、分离了表示层(观家者)和数据逻辑层(被观察者),并月建立了一套触发机制,使得数据的变化可以响应到多个表示层上;

3、实现了一对多的通讯机制,支持事件注册机制,支持兴趣分发机制,当被观察者触发事件时,只有感兴趣的观察者可以接收到通知

缺点：

1、如果观察者数量过多,则事件通知会耗时较长

2、事件通知呈线性关系,如果其中一个观察者处理事件卡壳,会影响后续的观察者接收该事件

3、如果观察者和被观察者之间存在循环依赖,则可能造成两者之间的循环调用,导致系统崩溃。

孰能生巧-LWP
关注
专栏目录
java常用设计模式-观察者模式
08-28
观察者模式（Observer Pattern）是一种行为设计模式，它定义了一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖它的对象都会得到通知并自动更新。该模式适用于需要在对象间建立动态的、松散耦合的关系的...
设计模式-观察者模式-作业-observer.zip
08-27
观察者模式（Observer Pattern）是软件设计模式中的行为模式之一，它定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。这种模式常用于实现事件驱动或发布-...
Laravel核心代码学习 -- 观察者模式
weixin_34122604的博客
06-06 193
观察者模式 Laravel的Event事件系统提供了一个简单的观察者模式实现，能够订阅和监听应用中发生的各种事件，在PHP的标准库(SPL)里甚至提供了三个接口SplSubject, SplObserver, SplObjectStorage来让开发者更容易地实现观察者模式，不过我还是想脱离SPL提供的接口和特定编程语言来说一下如何通过面向对象程序设计来实现观察者模式，示例是PHP代码不过用其他面...
观察者模式 详解
GeorgeWang
06-18 1363
定义 一个或多个观察者对目标的状态感兴趣，它们通过将自己依附在目标对象上以便注册所感兴趣的内容。 目标状态发生改变并且观察者可能对这些改变感兴趣，就会发送一个通知消息，调用每个观察者的更新方法。 当观察者不再对目标感兴趣的时候，它们可以简单的将自己从中分离。 组成角色 抽象目标角色（AbstractSubject） 抽象观察者角色（AbstractObserver） 具体目标角色（ConcreteS
观察者模式
田维常
06-17 199
关注公众号“Java后端技术全栈”回复“000”获取程序员必备电子书大家好，我是老田，今天我给大家分享设计模式中的观察者模式。用贴切的生活故事，以及真实项目场景来讲设计模式，最后用一句话来...
观察者模式总结
成功不必在我，然功力必不唐娟
11-03 1326
观察者模式由两部分zuchang 观察者模式核心思想：
设计模式：第二章 观察者模式
追梦的土豆的博客
04-03 640
设计模式之观察者模式
设计模式-观察者模式（Observer）
miaoyl的博客
11-14 1376
观察者模式（Observer Pattern）是一种行为型设计模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。观察者模式包含以下角色：主题（Subject）：被观察的对象，维护一个观察者列表，提供添加、删除和通知观察者的方法。观察者（Observer）：观察主题对象的状态变化，实现 Update 方法来更新自己的状态。
行为设计模式 -观察者模式- JAVA
智的博客
10-03 1634
观察者模式是一种对象行为模式。又被称为发布-订阅（Publish/Subscribe）模式， 它定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。在观察者模式中，主体是通知的发布者，它发出通知时并不需要知道谁是它的观察者，可以有任意数目的观察者订阅并接收通知。观察者模式不仅被广泛应用于软件界面元素之间的交互，在业务对象之间的交互、权限管理等方面也有广泛的应用。这个模式在日常开发中很常见，比如a服务想要b服务磁盘满的时候通知它，那么它只需要把自己的。
设计模式-观察者模式（讲解及其实现代码）
07-05
总结来说，观察者模式是一种重要的设计模式，它允许对象在状态改变时自动通知其他对象，从而降低了系统各部分之间的耦合度，提高了代码的灵活性和可扩展性。在实际项目中，正确使用观察者模式可以有效地管理组件间的...
JAVA-设计模式-行为型模式-观察者模式
08-10
JAVA-设计模式-行为型模式-观察者模式
LabVIEW提高开发效率技巧----调度器设计模式
bjcyck的博客
10-04 1262
在LabVIEW开发中，针对多任务并行的需求，使用调度器设计模式（Scheduler Pattern）可以有效地管理多个任务，确保它们根据优先级或时间间隔合理执行。这种模式在需要多任务并发执行时特别有用，尤其是在实时系统、数据采集、硬件控制等场景中。
设计模式-适配器模式
ZSS1753936255的博客
10-02 614
这段代码就是在适配器Adapter中关联了适配器适配器母接口Speker. 在适配器中的translate中实现了 speaker.speak()方法。首先：如何调用被适配的对象呢？可以通过 关联或者继承 适配器来实现。（1：这段代码是通过是通过继承来实现的，也达到了接口转换的目的）适配器模式：将一类的接口转换成满足用户需求的另一种接口。是的不相容的接口得以共同工作。2:通过对象关联的方法来实现适配器，就是上述的UML类图保持一致。
设计模式-模版方法模式
ZSS1753936255的博客
10-04 724
模版方法模式(Template Method):定义一个操作中的算法骨架，而将一些步骤延迟到子类中，使得子类可以不改变一个算法的结构即可重新定义算法的某些定义步骤。抽象类：负责实现一个算法的骨架，他是由一个final修饰的模版方法和若干个基本方法组成的。
设计模式-迭代器模式
ZSS1753936255的博客
10-04 486
他们提供了迭代器可以对外提供访问数据的接口，同时没有暴露内部的存储逻辑（根据上面的代码中，外部的端口是根据 while(i.hasNext) 来获取对象数据的，但是外部端口并不知道 获取到的每一个对象的结构类型是什么样的。所以就是说，没有暴露内部的逻辑储存）迭代器模式的作用就是将迭代元素的责任交给了迭代器，而不是聚合对象。我们甚至都不需要知道聚合对象内部结构就可以实现该聚合对象的迭代。迭代器模式(Interperter)：提供一种方法顺序访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示。
设计模式之---工厂模式
最新发布
Arguan_的博客
10-10 499
抽象工厂模式主要用于创建相关对象的家族。当一个产品族中需要被设计在一起工作时，通过抽象工厂模式，能够保证客户端始终只使用同一个产品族中的对象；并且通过隔离具体类的生成，使得客户端不需要明确指定具体生成类；所有的具体工厂都实现了抽象工厂中定义的公共接口，因此只需要改变具体工厂的实例，就可以在某种程度上改变整个软件系统的行为。但该模式的缺点在于添加新的行为时比较麻烦，如果需要添加一个新产品族对象时，需要更改接口及其下所有子类，这必然会带来很大的麻烦。System.out.println("生产狗粮");
设计模式之访问者
qq_74811378的博客
10-02 1266
（Visitor） 是一种行为设计模式， 它能将算法与其所作用的对象隔离开来。适用场景代码如下：问题：做一款生成冰激凌和雪糕的程序，要求可以扩展新的口味，并且可以扩展新的包装方式。解决方案：表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值