设计模式之观察者模式(Observer)

最新推荐文章于 2022-06-10 15:13:49 发布
最新推荐文章于 2022-06-10 15:13:49 发布
阅读量1.2w 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A_Java_Dog/article/details/117772868
版权

观察者模式

观察者模式

在这里插入图片描述
在观察者模式中，事件源，观察者，事件是一个组合。

事件源Source对象，拥有一堆Observer，然后他会发出一堆Event，Observer观察到Event之后会做出具体的反应。

问题

一个小孩，醒了会哭，需要有人照顾。

代码实现

版本一

  • 面向过程
package com.cyc.design.observer.v1;

/**
 * 披着面向对象外衣的面向过程
 */

public class Main1 {
    public static void main(String[] args) {
        boolean cry = false;

        while(!cry) {
            //对小孩哭这一事件进行处理
        }
    }
}

版本二

  • 面向对象
package com.cyc.design.observer.v2;

/**
 * 面向对象的傻等
 */

class Child {
    private boolean cry = false;

    public boolean isCry() {
        return cry;
    }

    public void wakeUp() {
        System.out.println("Waked Up! Crying wuwuwuwu...");
        cry = true;
    }
}

public class Main {
    public static void main(String[] args) {
        Child child = new Child();
        while(!child.isCry()) {
            try {
                //如果没有哭，就一直等待，一直观察
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("observing...");
        }

    }
}

和版本一没有区别 ，本质上就是在等。

版本三

  • 加入观察者Dad
package com.mashibing.dp.observer.v3;

/**
 * 加入观察者
 */

class Child {
    private boolean cry = false;
    private Dad d = new Dad();

    public boolean isCry() {
        return cry;
    }

    public void wakeUp() {
        cry = true;
        //Dad 作为观察者，处理孩子哭的事件
        d.feed();
    }
}

class Dad {
    public void feed() {
        System.out.println("dad feeding...");
    }
}

public class Main {
    public static void main(String[] args) {
        Child c = new Child();
        //do sth
        c.wakeUp();
    }
}

但是这种方式耦合度过高，不利于扩展

版本四

  • 加入多个观察者，每个观察者都可以处理这件事，处理方式都不同
package com.mashibing.dp.observer.v4;

/**
 * 加入多个观察者
 */

class Child {
    private boolean cry = false;
    private Dad dad = new Dad();
    private Mum mum = new Mum();
    private Dog dog = new Dog();


    public boolean isCry() {
        return cry;
    }

    public void wakeUp() {
        cry = true;
        dad.feed();
        dog.wang();
        mum.hug();
    }
}

class Dad {
    public void feed() {
        System.out.println("dad feeding...");
    }
}

class Mum {
    public void hug() {
        System.out.println("mum hugging...");
    }
}

class Dog {
    public void wang() {
        System.out.println("dog wang...");
    }
}

public class Main {
    public static void main(String[] args) {
        Child c = new Child();
        //do sth
        c.wakeUp();
    }
}

但是这种也不够灵活，假如观察者还要处理别的事件，例如，dog不止在小孩哭的时候叫，在看到陌生人的时候也会叫。那这种处理方式就无法满足此需求

也就是说观察者对于事件的反应不一定要耦合到某一个特定的观察对象上。

版本五

  • 分离观察者与被观察者

任何一个观察者在小孩哭了之后，都要做出某些反应。所以这里定义一个观察类接口，其他观察者实现这个接口。小孩对象中也不再写死某个观察者，而是通过代码块的方式进行加载。而在wake方法中，通过遍历观察者的方式进行对该小孩哭这一事件的处理。这些observer其实就是多态的应用，和责任链模式相似。

package com.cyc.design.observer.v5;

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

/**
 * 分离观察者与被观察者
 */

class Child {
    private boolean cry = false;
    private List<Observer> observers = new ArrayList<>();

    {
        observers.add(new Dad());
        observers.add(new Mum());
        observers.add(new Dog());
    }


    public boolean isCry() {
        return cry;
    }

    public void wakeUp() {
        cry = true;
        for(Observer o : observers) {
            o.actionOnWakeUp();
        }
    }
}

interface Observer {
    void actionOnWakeUp();
}

class Dad implements Observer {
    public void feed() {
        System.out.println("dad feeding...");
    }

    @Override
    public void actionOnWakeUp() {
        feed();
    }
}

class Mum implements Observer {
    public void hug() {
        System.out.println("mum hugging...");
    }

    @Override
    public void actionOnWakeUp() {
        hug();
    }
}

class Dog implements Observer {
    public void wang() {
        System.out.println("dog wang...");
    }

    @Override
    public void actionOnWakeUp() {
        wang();
    }
}

public class Main {
    public static void main(String[] args) {
        Child c = new Child();
        //do sth
        c.wakeUp();
    }
}

版本六

很多时候，观察者需要根据事件的具体情况做出反应，所以这里新建一个事件类，child负责发出这个事件, 将child醒了之后的所有状况封装到wakeUpEvent事件对象中。

package com.cyc.design.observer.v6;

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

/**
 * 有很多时候，观察者需要根据事件的具体情况来进行处理
 */

class Child {
    private boolean cry = false;
    private List<Observer> observers = new ArrayList<>();

    {
        observers.add(new Dad());
        observers.add(new Mum());
        observers.add(new Dog());
    }


    public boolean isCry() {
        return cry;
    }

    public void wakeUp() {
        cry = true;

        wakeUpEvent event = new wakeUpEvent(System.currentTimeMillis(), "bed");

        //将事件传递给所有观察者，让其处理
        for(Observer o : observers) {
            o.actionOnWakeUp(event);
        }
    }
}

//事件类 fire Event
class wakeUpEvent{
    //时间
    long timestamp;
    //地点
    String loc;

    public wakeUpEvent(long timestamp, String loc) {
        this.timestamp = timestamp;
        this.loc = loc;
    }
}

interface Observer {
    void actionOnWakeUp(wakeUpEvent event);
}

class Dad implements Observer {
    public void feed() {
        System.out.println("dad feeding...");
    }

    @Override
    public void actionOnWakeUp(wakeUpEvent event) {
        feed();
    }
}

class Mum implements Observer {
    public void hug() {
        System.out.println("mum hugging...");
    }

    @Override
    public void actionOnWakeUp(wakeUpEvent event) {
        hug();
    }
}

class Dog implements Observer {
    public void wang() {
        System.out.println("dog wang...");
    }

    @Override
    public void actionOnWakeUp(wakeUpEvent event) {
        wang();
    }
}

public class Main {
    public static void main(String[] args) {
        Child c = new Child();
        //do sth
        c.wakeUp();
    }
}

在这里插入图片描述

版本七

大多数时候，我们处理事件的时候，需要知道事件源对象，观察者可以观察多个事件源，同样事件源也可以被多个观察者观察。此时事件对象中，就需要加入事件源对象了。

package com.cyc.design.observer.v7;

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

/**
 * 有很多时候，观察者需要根据事件的具体情况来进行处理
 * 大多数时候，我们处理事件的时候，需要知道事件源对象
 */

class Child {
    private boolean cry = false;
    private List<Observer> observers = new ArrayList<>();

    {
        observers.add(new Dad());
        observers.add(new Mum());
        observers.add(new Dog());
    }


    public boolean isCry() {
        return cry;
    }

    public void wakeUp() {
        cry = true;

        wakeUpEvent event = new wakeUpEvent(System.currentTimeMillis(), "bed", this);

        for(Observer o : observers) {
            o.actionOnWakeUp(event);
        }
    }
}

class wakeUpEvent{
    long timestamp;
    String loc;
    //加入事件源对象
    Child source;

    public wakeUpEvent(long timestamp, String loc, Child source) {
        this.timestamp = timestamp;
        this.loc = loc;
        this.source = source;
    }
}

interface Observer {
    void actionOnWakeUp(wakeUpEvent event);
}

class Dad implements Observer {
    public void feed() {
        System.out.println("dad feeding...");
    }

    @Override
    public void actionOnWakeUp(wakeUpEvent event) {
        feed();
    }
}

class Mum implements Observer {
    public void hug() {
        System.out.println("mum hugging...");
    }

    @Override
    public void actionOnWakeUp(wakeUpEvent event) {
        hug();
    }
}

class Dog implements Observer {
    public void wang() {
        System.out.println("dog wang...");
    }

    @Override
    public void actionOnWakeUp(wakeUpEvent event) {
        wang();
    }
}

public class Main {
    public static void main(String[] args) {
        Child c = new Child();
        //do sth
        c.wakeUp();
    }
}

版本八

事件也可以形成继承体系

查看java内部的事件体系 , 如KeyEvent

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

EventObject就是所有事件的父类, 因此代码可以这样写

package com.cyc.design.observer.v8;

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

/**
 * 有很多时候，观察者需要根据事件的具体情况来进行处理
 * 大多数时候，我们处理事件的时候，需要事件源对象
 * 事件也可以形成继承体系
 */

class Child {
    private boolean cry = false;
    private List<Observer> observers = new ArrayList<>();

    {
        observers.add(new Dad());
        observers.add(new Mum());
        observers.add(new Dog());
        observers.add((e)->{
            System.out.println("ppp");
        });
        //hook callback function
    }


    public boolean isCry() {
        return cry;
    }

    public void wakeUp() {
        cry = true;

        wakeUpEvent event = new wakeUpEvent(System.currentTimeMillis(), "bed", this);

        for(Observer o : observers) {
            o.actionOnWakeUp(event);
        }
    }
}

abstract class Event<T> {
    abstract T getSource();
}

class wakeUpEvent extends Event<Child>{
    long timestamp;
    String loc;
    Child source;

    public wakeUpEvent(long timestamp, String loc, Child source) {
        this.timestamp = timestamp;
        this.loc = loc;
        this.source = source;
    }

    @Override
    Child getSource() {
        return source;
    }
}

interface Observer {
    void actionOnWakeUp(wakeUpEvent event);
}

class Dad implements Observer {
    public void feed() {
        System.out.println("dad feeding...");
    }

    @Override
    public void actionOnWakeUp(wakeUpEvent event) {
        feed();
    }
}

class Mum implements Observer {
    public void hug() {
        System.out.println("mum hugging...");
    }

    @Override
    public void actionOnWakeUp(wakeUpEvent event) {
        hug();
    }
}

class Dog implements Observer {
    public void wang() {
        System.out.println("dog wang...");
    }

    @Override
    public void actionOnWakeUp(wakeUpEvent event) {
        wang();
    }
}

public class Main {
    public static void main(String[] args) {
        Child c = new Child();
        //do sth
        c.wakeUp();
    }
}

java本身观察者

package com.cyc.design.observer.v9;

import java.awt.Button;
import java.awt.Frame;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

public class TestFrame extends Frame {
	public void launch() {
		//AWT 的一个类, 表示一个按钮
		Button b = new Button("press me");
		//当鼠标点到按钮上后 , 会产生这件事
		b.addActionListener(new MyActionListener());
		b.addActionListener(new MyActionListener2());
		//将button放到窗口中
		this.add(b);
		//打包
		this.pack();

		this.addWindowListener(new WindowAdapter(){

			@Override
			public void windowClosing(WindowEvent e) {
				System.exit(0);
			}
			
		});
		this.setLocation(400, 400);
		this.setVisible(true);
	}
	
	public static void main(String[] args) {
		new TestFrame().launch();
	}

	//相当于Observer
	private class MyActionListener implements ActionListener { //Observer

		public void actionPerformed(ActionEvent e) {
			((Button)e.getSource()).setLabel("press me again!");
			System.out.println("button pressed!");
		}
		
	}
	
	private class MyActionListener2 implements ActionListener {

		public void actionPerformed(ActionEvent e) {
			System.out.println("button pressed 2!");
		}
		
	}
}

运行一下

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ob4KbmG0-1623307878801)(C:\Users\fei\AppData\Local\Temp\1623297971449.png)]

小测试


public class Test {
    public static void main(String[] args) {
        Button b = new Button();
        b.addActionListener(new MyActionListener());
        b.addActionListener(new MyActionListener2());
        b.buttonPressed();
    }
}

class Button {

    private List<ActionListener> actionListeners = new ArrayList<ActionListener>();

    public void buttonPressed() {
        ActionEvent e = new ActionEvent(System.currentTimeMillis(), this);
        for (int i = 0; i < actionListeners.size(); i++) {
            ActionListener l = actionListeners.get(i);
            l.actionPerformed(e);
        }
    }

    public void addActionListener(ActionListener l) {
        actionListeners.add(l);
    }
}

interface ActionListener {
    void actionPerformed(ActionEvent e);
}

/**
 * 观察者1
 */
class MyActionListener implements ActionListener {

    public void actionPerformed(ActionEvent e) {
        System.out.println("button pressed!");
    }

}

/**
 * 观察者2
 */
class MyActionListener2 implements ActionListener {

    public void actionPerformed(ActionEvent e) {
        System.out.println("button pressed 2!");
    }

}

class ActionEvent {
    //事件对象, 包含两个参数, 时间和事件源
    long when;
    Object source;

    public ActionEvent(long when, Object source) {
        super();
        this.when = when;
        this.source = source;
    }


    public long getWhen() {
        return when;
    }

    public Object getSource() {
        return source;
    }

}

总结

Observer , listener, Hook, Callback , 这些都是观察者模式

在很多系统中，Observer模式往往和责任链共同负责对于事件的处理，
其中的某一个observer负责是否将事件进一步传递

意田天
关注
专栏目录
浏览器观察者 Observer API
yangyingkuan的博客
02-20 622
随着浏览器的发展，现代浏览器支持四种不同类型的观察者。1.Intersection Observer 交叉观察者2.Mutation Observer 变动观察者3.Resize Observer 视图观察者4.Performance Observer 性能观察者。
现代浏览器观察者 Observer API 指南
前端劝退师
10-24 1846
前言前段时间在研究前端异常监控/埋点平台的实现。在思考方案时，想到了浏览器自带的观察者以及页面生命周期API 。于是在翻查资料时意外发现，原来现代浏览器支持多达四种不同类...
document.observe用法详解
友间博客
01-14 870
observe(eventName, handler) -&gt; document侦听整个文档范围内的给定事件。也可以用于侦听 "dom:loaded" 事件。 document.observe 是 Element#observe 基于整个文档范围的版本。它与 Event.observe(document, eventName, handler) 是等价的。 "dom:loaded" 事...
swiper一个板块，多个切换轮播。使用display:none后，swiper显示错误
我不晓得
03-26 601
observer:true,//当改变swiper的样式（例如隐藏/显示）或者修改swiper的子元素时，自动初始化swiper observeParents:true,//修改swiper的父元素时，自动初始化swiper 初始化swiper就可以解决 observer:true, observerParents:true; new Swiper('.lan-special-cont1', { slidesPerView:3, ...
swiper 使用
sinat_38914900的博客
05-26 472
1、在元素display: none 时，不执行 设定参数（最低支持swiper版本 3.0.0 ） observer:true,//修改swiper自己或子元素时，自动初始化swiper observeParents:true//修改swiper的父元素时，自动初始化swiper
PHP设计模式之观察者模式(Observer)详细介绍和代码实例
10-26
观察者模式是一种行为设计模式，它定义了对象间的一种一对多的依赖关系，使得当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。这种模式经常用于实现软件的分布式事件通知系统，例如，图形...
设计模式C++学习之观察者模式（Observer）
09-07
观察者模式（Observer）是软件设计模式中的一种行为模式，它定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并被自动更新。这种模式在C++中广泛应用，特别是在需要...
C++设计模式之观察者模式（Observer）
08-27
C++设计模式之观察者模式（Observer） 观察者模式（Observer）是一种常用的设计模式，它主要用于解决对象之间的一对多关系问题。在这种模式中，一个对象（被观察者）维护一个观察者对象的集合，当被观察者对象变化...
Java设计模式之观察者模式（Observer模式）介绍
09-03
观察者模式（Observer模式）是软件设计模式中的一种行为模式，它定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并被自动更新。在Java中，这个模式是通过`java.util....
C#设计模式之Observer观察者模式解决牛顿童鞋成绩问题示例
08-29
观察者模式（Observer Pattern）是软件设计模式中的一种行为模式，它定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。在C#中，我们可以利用事件和委托来...
vue中swiper的使用（轮播失效）
06-23 2325
在使用vue写swiper轮播图的时候， 有时会发生轮播图不生效的问题， 这是因为页面中JS执行的顺序问题， 这时swiper中的Observer（监视器）就派上用场了； observer:true, // 修改swiper自己或子元素时，自动初始化swiper observeParents:true, // 修改swiper的父元素时，自动初始化swiper 在swiper中加上这是就可以进行动态监听了， 不过也需要注意的是：swiper应放在vue执行之后 具体代码如下： <!DOCT.
swiper 播放不生效/左右滑动无效/第一张图闪过
u012321370的博客
11-19 1394
swiper 播放不生效/左右滑动无效/第一张图闪过2020-06-16 16:29:36 var swiper = new Swiper(’.swiper-container’, { // direction: ‘horizontal’, // initialSlide: 0, // loop : true, // initialSlide :0, observer:true, //修改swiper自己或子元素时，自动初始化swiper observeParents:true, //修改swiper的
一个初学者对事件和Observer模式的理解
LeoChen的博客
01-20 925
什么是事件？他和Observer设计模式有什么关系? 对于这两个概念专业书有正规的解释，我不想照抄概念。 我站在一个初学者的角度谈一下自己的理解，“事件”大白话就是“出了点事情”或者说是“发生了一些事情”，既然发生了事情，那肯定涉及到人或物，这件事是谁导致的，有谁受了影响，造成了什么后果。Observe模式又叫做发布-订阅模式(Publish/Subscribe)，Observer中文意思是观
swiper——单页面多轮播插件冲突解决方案
NanChen的博客
06-10 1455
多个swiper在同一页面显示异常问题
关于继承的小问题
weixin_30852451的博客
11-04 78
运行一下代码 public class ParentChildTest { public static void main(String[] args) { Parent parent=new Parent(); parent.printValue(); Child child=new Child(); chi...
JavaScript核心之变动观察器（Mutation Observer）
上善若泪
05-03 8045
目录 1 变动观察器（mutation observer）概述 2 MutationObserver构造函数 3 Mutation Observer实例的方法 3.1 observe() 3.2 disconnect()，takeRecords（） 3.3 MutationRecord对象 4 应用示例 4.1 子元素的变动 4.2 属性的变动 4.3 取代DOMContent...
前端使用swiper的坑
douyiqing的博客
03-10 2025
1.动态渲染swiper左右切换按钮和滑动切换失效 原因：这是因为ajax是个异步请求，当页面渲染完毕时，swiper插件没法获取最新的swiper-slide个数，导致部分功能失效。 解决办法： 在swiper初始化时设置下面属性 observer: true, //修改swiper自己或子元素时，自动初始化swiper observeParents: true //修改swiper的...
选项卡下的swiper滑动和左右箭头失效
QSWの
04-02 629
给swiper添加这两句就可以了： observer:true, observeParents:true, 如图????
vue中通过方法返回data中的对象是这个{__ob__: Observer}
热门推荐
荆轲刺秦王
12-09 8万+
__ob__: Observer这些数据是vue这个框架对数据设置的监控器，一般都是不可枚举的。 console.log这样的打印函数，被打印的变量会执行自身的toString()，这样，即便内部属性是不可枚举，实际上也能看到。 操作数据的过程中不要删除这些属性： 因为你已经将数据绑定在了vue之中，vue就肯定要为数据添加监控器的，如果你强制删掉了这些监控器，那么这些数据也就失去了监...
PHP设计模式：深入理解观察者模式(Observer)
本文详细介绍了PHP中的观察者模式（Observer），一种用于建立对象间一对多关系的设计模式。当一个对象的状态发生变化时，所有依赖它的对象都会收到通知并自动更新。 观察者模式的主要意图是定义一个一对多的依赖...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

意田天

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值