设计模式之观察者(Observer)

simpleGq2023-11-09 8:23

事件处理模型

小朋友睡醒了就哭，饿

写程序模拟这个过程：

v1:最简单的就是写程序一直观察着，什么时候哭了就进行处理

java 复制代码 
/**
 * 披着面向对象外衣的面向过程
 */
public class Main1 {
    public static void main(String[] args) {
        boolean cry = false;

        while(!cry) {
            //进行处理
        }
    }
}

v2: 面向对象，至少抽象出child类来：

java 复制代码 
/**
 * 面向对象的傻等
 * 一直观察，直到有线程调用了wakeUp方法
 * 程序没写完，涉及到线程同步，没有写完
 */

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...");
        }

    }
}

v3: 加入观察者Dad到被观察者Child里面，什么时候醒了，直接调用观察者的方法

java 复制代码 
/**
 * 加入观察者
 */

class Child {
    private boolean cry = false;
    private Dad d = new Dad(); //加入观察者Dad到被观察者Child里面

    public boolean isCry() {
        return cry;
    }

    public void wakeUp() {
        cry = true;
        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();
    }
}

v4：加入多个观察者，当一个事件发生的时候，每个观察者的处理方式不同

java 复制代码 
/**
 * 加入多个观察者
 */

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...");
    }
}

耦合度太高，观察者的处理方法不一定只适合当前的被观察者，例如小狗汪汪叫这个出来方法，可能也适合于鸡叫的事件

而且添加新的观察者比较麻烦 --> 扩展性不好，耦合度高

v5：分离观察者与被观察者。定义一个Observer接口，里面有actionWeakup方法，指的是小孩醒了之后要采取的动作，不同的观察者实现这Observer个接口

java 复制代码 
/**
 * 分离观察者与被观察者
 */
class Child {
    private boolean cry = false;
    // 将观察者放到list中
    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;
        // 当wakeup事件发生的时候，遍历观察者进行处理
        for(Observer o : observers) {
            o.actionOnWakeUp();
        }
    }
}

// 定义一个Observer接口
interface Observer {
    void actionOnWakeUp();
}

//不同的观察者实现这个Observer接口  
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();
    }
}

一个事件发生，会经过一系列的观察者的处理，这个事件才算完成

v5:一个事件发生之后，观察者需要根据事件的具体情况，做出处理。例如小孩哭的厉不厉害，时间等

该怎么把小孩哭的事件的具体情况传递给观察者呢?

封装一个事件类，事件的所有情况都在事件里面：

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

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);
}

// Observer里面可以写if，判断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();
    }
}

观察者模式三要素：

Source事件源对象 --> 是谁发出的事件

Observer观察者 --> 是谁在等着这个事件

Event事件 --> 事件本身

事件源对象有一堆的观察者观察着它，当事件源对象发出事件的时候，观察者会对事件进行处理

V7：一个事件源可以发出不同的事件，一个事件也可以被多个观察者处理，大多数时候，我们处理事件的时候，需要事件源对象

为什么需要事件源对象：因为有时候需要根据事件源对象的不同，采用不同的处理方法。

Sping的AOP其实可以语义上理解成观察者模式，在程序执行的过程中，弄一个切面，当代码执行到这个切面的时候，先执行指定好的一系列方法，

然后继续往下，这就相当于观察者模式，观察着这个切面，当到达这个切面的时候，先执行一系列定义好的方法

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

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;
    }

    // 往往事件对象都会有一个getSource方法，例如系统提供的WindowEvent
    public Child getSource() {
        return this.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();
    }
}

v8:java里面的事件继承自EventObject这个类。

这里也自己定义了一个事件类，里面有getSource方法

钩子函数，hook，callback，listener都是观察者模式，都是一回事

java 复制代码 
/**
 * 有很多时候，观察者需要根据事件的具体情况来进行处理
 * 大多数时候，我们处理事件的时候，需要事件源对象
 * 事件也可以形成继承体系
 */
class Child {
    private boolean cry = false;
    private List<Observer> observers = new ArrayList<>();

    {
        observers.add(new Dad());
        observers.add(new Mum());
        observers.add(new Dog());
        // 钩子函数hook，钩在那里，当事件发生的时候，钩子函数被执行
        // 钩子函数就是Observer模式
        // 传过去的是个函数
        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);
        }
    }
}
// 定义抽象Event方法，里面有getSource方法
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();
    }
}

v9:java jwt里面用了观察者模式，点击button，所有的观察者listener会被触发

java 复制代码 
public class TestFrame extends Frame {
	public void launch() {
		Button b = new Button("press me");
		b.addActionListener(new MyActionListener());
		b.addActionListener(new MyActionListener2());
		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();
	}
	
	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!");
		}
		
	}
}

jvm运行着，监听着操作系统的键盘事件，当按键发生的时候，jvm会创建好KeyEvent事件

js里面也有event对象，事件源对象是event.traget。当按下button的时候，会自动生成event对象，把事件源对象传过去

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

Observer不存在往回传的情况 --> 责任链部分讲到

相关推荐
菜鸡且互啄6942 分钟前
在线教育平台，easyexcel使用案例
java·开发语言
八月林城42 分钟前
JAVA导出数据库字典到Excel
java·数据库·excel
浅念同学3 小时前
算法-常见数据结构设计
java·数据结构·算法
杰哥在此5 小时前
Java面试题：讨论持续集成/持续部署的重要性，并描述如何在项目中实施CI/CD流程
java·开发语言·python·面试·编程
咖啡煮码5 小时前
深入剖析Tomcat(十五、十六) 关闭钩子，保证Tomcat的正常关闭
java·tomcat
Ｃ.C5 小时前
java IO流(1)
java·开发语言
明戈戈7 小时前
设计模式-模板方法模式
设计模式·模板方法模式
python资深爱好者7 小时前
在什么情况下你会使用设计模式
设计模式
黑头！7 小时前
Tomcat注册为服务之后 运行时提示JVM异常
java·jvm·tomcat
袁震7 小时前
Java---Mybatis详解二
java·开发语言·mybatis
热门推荐
012024年江苏省研究生数学建模科研创新实践大赛C题气象数据高精度融合技术研究论文和代码分析02Coze扣子平台完整体验和实践（附国内和国际版对比）03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）042024亚太赛（中文赛）数学建模竞赛选题建议+初步分析05yolov8实战第五天——yolov8+ffmpg实时视频流检测并进行实时推流——（推流，保姆教学）06【经验分享】Ubuntu22.04安装微信(linux官方版)07通用大模型VS垂直大模型，你更青睐哪一方？082025张宇考研数学，百度网盘视频课+36讲PDF讲义+真题09【立创EDA-PCB设计基础】6.布线铺铜实战及细节详解102024 年第十四届 APMCM 亚太地区大学生数学建模竞赛B题超详细解题思路+数据预处理问题一代码分享