1. 事件处理模型
  2. 事件处理经常用观察者模式+责任链模式
  3. 需要详细掌握
  4. reactor设计模式本质也是observer

情景引入

  • 小朋友睡醒了，饿！——> 哭 ——> 喂奶

UML类图

image.png

处理方式

v1披着面向对象外衣的面向过程

  • 干等着，阻塞，浪费cpu资源 ```java package com.mashibing.dp.observer.v1;

/**

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

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

  1.     while(!cry) {
  2.         //进行处理
  3.     }
  4. }

}

  2. <a name="CU5ca"></a>
  3. ### v2面向对象的傻等
  5. - 另一个线程调用wakeUp
  6. - 多线程同步
  7. ```java
  8. package com.mashibing.dp.observer.v2;
  10. /**
  11.  * 面向对象的傻等
  12.  */
  14. class Child {
  15.     private boolean cry = false;
  17.     public boolean isCry() {
  18.         return cry;
  19.     }
  21.     public void wakeUp() {
  22.         System.out.println("Waked Up! Crying wuwuwuwu...");
  23.         cry = true;
  24.     }
  25. }
  27. public class Main {
  28.     public static void main(String[] args) {
  29.         Child child = new Child();
  30.         while(!child.isCry()) {
  31.             try {
  32.                 Thread.sleep(1000);
  33.             } catch (InterruptedException e) {
  34.                 e.printStackTrace();
  35.             }
  36.             System.out.println("observing...");
  37.         }
  38.         // 观察者进行相应的处理
  39.     }
  40. }

v3加入观察者dad

  • 处理过程放在wakeUp方法中了
  • 将观察者放进被观察者中，触发事件就调用观察者相应的处理方法
  • 耦合度太高，不灵活
  • 想多加几个观察者要修改代码，不符合开闭原则 ```java package com.mashibing.dp.observer.v3;

/**

  • 加入观察者 */

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

  1. public boolean isCry() {
  2.     return cry;
  3. }
  5. public void wakeUp() {
  6.     cry = true;
  7.     d.feed();
  8. }

}

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

  2. <a name="Us6nK"></a>
  3. ### v4多个观察者
  5. - 加入新的观察者时会很费劲（要改两个地方）
  6. - 不灵活
  7. - 观察者有些方法不想跟被观察者耦合到一起（狗看到陌生人叫，小孩醒了也叫，只作为自己的业务方法）
  8. - 耦合度太高
  9. ```java
  10. package com.mashibing.dp.observer.v4;
  12. /**
  13.  * 加入多个观察者
  14.  */
  16. class Child {
  17.     private boolean cry = false;
  18.     private Dad dad = new Dad();
  19.     private Mum mum = new Mum();
  20.     private Dog dog = new Dog();
  23.     public boolean isCry() {
  24.         return cry;
  25.     }
  27.     public void wakeUp() {
  28.         cry = true;
  29.         dad.feed();
  30.         dog.wang();
  31.         mum.hug();
  32.     }
  33. }
  35. class Dad {
  36.     public void feed() {
  37.         System.out.println("dad feeding...");
  38.     }
  39. }
  41. class Mum {
  42.     public void hug() {
  43.         System.out.println("mum hugging...");
  44.     }
  45. }
  47. class Dog {
  48.     public void wang() {
  49.         System.out.println("dog wang...");
  50.     }
  51. }
  53. public class Main {
  54.     public static void main(String[] args) {
  55.         Child c = new Child();
  56.         //do sth
  57.         c.wakeUp();
  58.     }
  59. }

v5用存放Observer接口类型的List保存所有观察者

  • 所有的观察者都实现Observer接口
  • 所有的观察者重写actionOnWakeUp，做出动作发出后的相应的动作
  • 观察者模式与责任链模式有很多相似的地方，常常一起用
  • 观察者模式实际上是对多态的灵活运用
  • 而Observer经常串在一起，事件发生时，要经过这些事件的处理才算完事；假如其中有一个处理完之后不想往下传递了，就是责任链模式
  • 观察者模式—->同时发生，但也会有调用的先后顺序
    • 鼠标点击事件首先传给操作系统
    • 操作系统处理
    • 经过一层一层地传递
    • 最终传递到触发鼠标点击事件的窗口
  • 责任链模式能中断，但观察者一般是不中断的

image.png

  1. package com.mashibing.dp.observer.v5;
  3. import java.util.ArrayList;
  4. import java.util.List;
  6. /**
  7.  * 分离观察者与被观察者
  8.  */
  10. class Child {
  11.     private boolean cry = false;
  12.     // 因为有很多观察者并且数量不确定，所以可以用一接口类型的列表来存
  13.     // 实现接口必须重写actionOnWakeUp方法让被观察者发生某一动作后通过for循环调用
  14.     private List<Observer> observers = new ArrayList<>();
  16.     {
  17.         observers.add(new Dad());
  18.         observers.add(new Mum());
  19.         observers.add(new Dog());
  20.     }
  23.     public boolean isCry() {
  24.         return cry;
  25.     }
  27.     public void wakeUp() {
  28.         cry = true;
  29.         for(Observer o : observers) {
  30.             o.actionOnWakeUp();
  31.         }
  32.     }
  33. }
  35. interface Observer {
  36.     void actionOnWakeUp();
  37. }
  39. class Dad implements Observer {
  40.     public void feed() {
  41.         System.out.println("dad feeding...");
  42.     }
  44.     @Override
  45.     public void actionOnWakeUp() {
  46.         feed();
  47.     }
  48. }
  50. class Mum implements Observer {
  51.     public void hug() {
  52.         System.out.println("mum hugging...");
  53.     }
  55.     @Override
  56.     public void actionOnWakeUp() {
  57.         hug();
  58.     }
  59. }
  61. class Dog implements Observer {
  62.     public void wang() {
  63.         System.out.println("dog wang...");
  64.     }
  66.     @Override
  67.     public void actionOnWakeUp() {
  68.         wang();
  69.     }
  70. }
  72. public class Main {
  73.     public static void main(String[] args) {
  74.         Child c = new Child();
  75.         //do sth
  76.         c.wakeUp();
  77.     }
  78. }

v6观察者根据被观察者在不同情况下做出不同反应

  • 将事件单独分离出来，成为一个事件类
  • 事件类封装了事件源对象（即被观察者）的情况（child哭的时间、地点等），并传给事件监听者（即观察者）
  • 被观察者要发出事件（fire event）
  • 类比生产者-消费者模式（发布-订阅模式）
    • 被观察者生产一事件，观察者去消费
    • 模式灵活用，不硬套
  • 将事件类型作为actionOnWakeUp的参数传给观察者
  • 有以下几种角色
    • 事件源对象（产生事件对象，也称被观察者）
    • 事件（被观察者发出的事件，包括事件发生的context）
    • 事件监听器（根据事件作出相应的动作，也称观察者，观察事件） ```java package com.mashibing.dp.observer.v6;

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

/**

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

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

  1. {
  2.     observers.add(new Dad());
  3.     observers.add(new Mum());
  4.     observers.add(new Dog());
  5. }
  8. public boolean isCry() {
  9.     return cry;
  10. }
  12. public void wakeUp() {
  13.     cry = true;
  15.     wakeUpEvent event = new wakeUpEvent(System.currentTimeMillis(), "bed");
  17.     for(Observer o : observers) {
  18.         o.actionOnWakeUp(event);
  19.     }
  20. }

}

//事件类 fire Event class wakeUpEvent{ long timestamp; String loc;

  1. public wakeUpEvent(long timestamp, String loc) {
  2.     this.timestamp = timestamp;
  3.     this.loc = loc;
  4. }

}

interface Observer { void actionOnWakeUp(wakeUpEvent event); }

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

  1. @Override
  2. public void actionOnWakeUp(wakeUpEvent event) {
  3.     feed();
  4. }

}

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

  1. @Override
  2. public void actionOnWakeUp(wakeUpEvent event) {
  3.     hug();
  4. }

}

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

  1. @Override
  2. public void actionOnWakeUp(wakeUpEvent event) {
  3.     wang();
  4. }

}

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

  3. <a name="isrRi"></a>
  4. ### v7观察者获取事件源对象
  6. - 观察者有时候需要知道事件源对象（根据不同的对象进行处理）
  7.    - why？because观察者需要根据事件源对象进行不同的处理或者观察者的处理过程中需要用到事件源对象中的一些资源
  8. - 事件源可以发出好多不同的动作
  9. - 观察者的动作和事件源本身并不是完完全全的耦合在一起
  10.    - 观察者面对不同的动作时可以采取相同的动作
  11.    - 一个观察者可以监听在多个事件源上
  12.    - 事件源也可以发出好多个不同的事件
  13. - 事件源、事件和事件监听器之间的耦合并不是那么强（有耦合-->List集合）
  14. - ❓spring中的aop切面，观察者观察在切面上，spring中的耦合度更低?
  15.    - 语义上是一个Observer（咬文嚼字）
  16.    - spring中的事件源对象没必要维护一个观察者（监听器）集合，而是通过配置文件切进去即可
  17.    - 本质上是一个代理
  18. - 解决方案：
  19.    - 首先不能将事件源对象直接作为观察者的成员变量（耦合度太高了--->只能观察一个对象，观察了小狗就不能观察小鸟了）
  20.    - 将事件源对象放进事件event中去--->source，观察者需要用就通过event.getSource调用
  21. ```java
  22. package com.mashibing.dp.observer.v7;
  24. import java.util.ArrayList;
  25. import java.util.List;
  27. /**
  28.  * 有很多时候，观察者需要根据事件的具体情况来进行处理
  29.  * 大多数时候，我们处理事件的时候，需要事件源对象
  30.  */
  32. class Child {
  33.     private boolean cry = false;
  34.     private List<Observer> observers = new ArrayList<>();
  36.     {
  37.         observers.add(new Dad());
  38.         observers.add(new Mum());
  39.         observers.add(new Dog());
  40.     }
  43.     public boolean isCry() {
  44.         return cry;
  45.     }
  47.     public void wakeUp() {
  48.         cry = true;
  50.         // 将被观察者自身传进event中
  51.         wakeUpEvent event = new wakeUpEvent(System.currentTimeMillis(), "bed", this);
  53.         for(Observer o : observers) {
  54.             o.actionOnWakeUp(event);
  55.         }
  56.     }
  57. }
  59. class wakeUpEvent{
  60.     long timestamp;
  61.     String loc;
  62.     Child source;
  64.     public wakeUpEvent(long timestamp, String loc, Child source) {
  65.         this.timestamp = timestamp;
  66.         this.loc = loc;
  67.         this.source = source;
  68.     }
  70.     //获取事件源对象
  71.     public Child getSource() {
  72.         return source;
  73.     }
  75.     // 其他的set、get方法
  76. }
  78. interface Observer {
  79.     void actionOnWakeUp(wakeUpEvent event);
  80. }
  82. class Dad implements Observer {
  83.     public void feed() {
  84.         System.out.println("dad feeding...");
  85.     }
  87.     @Override
  88.     public void actionOnWakeUp(wakeUpEvent event) {
  89.         feed();
  90.     }
  91. }
  93. class Mum implements Observer {
  94.     public void hug() {
  95.         System.out.println("mum hugging...");
  96.     }
  98.     @Override
  99.     public void actionOnWakeUp(wakeUpEvent event) {
  100.         hug();
  101.     }
  102. }
  104. class Dog implements Observer {
  105.     public void wang() {
  106.         System.out.println("dog wang...");
  107.     }
  109.     @Override
  110.     public void actionOnWakeUp(wakeUpEvent event) {
  111.         wang();
  112.     }
  113. }
  115. public class Main {
  116.     public static void main(String[] args) {
  117.         Child c = new Child();
  118.         //do sth
  119.         c.wakeUp();
  120.     }
  121. }

v8事件的继承体系

  • Event抽象类作为父类
  • T为事件源对象的类型
  • 抽象类中有一抽象方法：abstract T getSource();
  • 主要目的就是为了使getSource更加通用 ```java package com.mashibing.dp.observer.v8;

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

/**

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

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

  1. {
  2.     observers.add(new Dad());
  3.     observers.add(new Mum());
  4.     observers.add(new Dog());
  5.     observers.add((e)->{
  6.         System.out.println("ppp");
  7.     });
  8.     //hook callback function
  9. }
  12. public boolean isCry() {
  13.     return cry;
  14. }
  16. public void wakeUp() {
  17.     cry = true;
  19.     wakeUpEvent event = new wakeUpEvent(System.currentTimeMillis(), "bed", this);
  21.     for(Observer o : observers) {
  22.         // 事件沿一个一个观察者往下传（Observer可以决定是否向下传？返回值或者第三个参数）
  23.         // 上一条注释详见责任链模式
  24.         o.actionOnWakeUp(event);
  25.     }
  26. }

}

abstract class Event { abstract T getSource(); }

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

  1. public wakeUpEvent(long timestamp, String loc, Child source) {
  2.     this.timestamp = timestamp;
  3.     this.loc = loc;
  4.     this.source = source;
  5. }
  7. @Override
  8. Child getSource() {
  9.     return source;
  10. }
  12. // 其他的set、get方法

}

interface Observer { void actionOnWakeUp(wakeUpEvent event); }

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

  1. @Override
  2. public void actionOnWakeUp(wakeUpEvent event) {
  3.     feed();
  4. }

}

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

  1. @Override
  2. public void actionOnWakeUp(wakeUpEvent event) {
  3.     hug();
  4. }

}

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

  1. @Override
  2. public void actionOnWakeUp(wakeUpEvent event) {
  3.     wang();
  4. }

}

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

  2. <a name="qOo7S"></a>
  3. ### v9Java AWT自带的观察者模式
  5. - 那些方法是由AWT框架本身帮你调
  6. - jvm监听os的键盘事件，生成KeyEvent对象，调用keyPressed方法（即触发了事件）
  7. - os监听到键盘事件，发现是个java程序，便将产生的键盘事件交给jvm，最后由jvm调用监听器的处理方法
  8. ```java
  9. package com.mashibing.dp.observer.v9;
  11. import java.awt.Button;
  12. import java.awt.Frame;
  13. import java.awt.event.ActionEvent;
  14. import java.awt.event.ActionListener;
  15. import java.awt.event.WindowAdapter;
  16. import java.awt.event.WindowEvent;
  18. public class TestFrame extends Frame {
  19.     public void launch() {
  20.         Button b = new Button("press me");
  21.         b.addActionListener(new MyActionListener());
  22.         b.addActionListener(new MyActionListener2());
  23.         this.add(b);
  24.         // 使按钮充满Frame窗口
  25.         this.pack();
  27.         this.addWindowListener(new WindowAdapter(){
  29.             @Override
  30.             public void windowClosing(WindowEvent e) {
  31.                 System.exit(0);
  32.             }
  34.         });
  35.         // 设定大小
  36.         this.setLocation(400, 400);
  37.         this.setVisible(true);
  38.     }
  40.     public static void main(String[] args) {
  41.         new TestFrame().launch();
  42.     }
  44.     private class MyActionListener implements ActionListener { //Observer
  46.         @Overwrite
  47.         public void actionPerformed(ActionEvent e) {
  48.             ((Button)e.getSource()).setLabel("press me again!");
  49.             System.out.println("button pressed!");
  50.         }
  52.     }
  54.     private class MyActionListener2 implements ActionListener {
  56.         @Overwrite
  57.         public void actionPerformed(ActionEvent e) {
  58.             System.out.println("button pressed 2!");
  59.         }
  61.     }
  62. }

v10javascript事件

认识javascript event对象

  1. <script type="text/javascript">
  2.   function handle() {
  3.       alert(event.target.value);
  4.     }
  5. </script>
  7. <input type="button" value="press me" onclick="handle()"/>

v11observer与责任链共用

在很多系统中，Observer模式往往和责任链共同负责对于事件的处理， 其中的某一个observer负责是否将事件进一步传递或者不传递 本质就是事件对象event穿过Observer的链条 不会往回传（责任链中的response可以往回传）

钩子函数（hook callback function）

  • 本质上就是Observer
  • 1.8后可以用lambda表达式传入函数对象（js、python、c++、……都可以）
  • 相当于把方法传过去；只不过之前java中不支持，所以传的是接口
  • hook、callback、listener、observer说的是一回事

🤏随想

  1. 内部类（嵌套类）可以直接使用外部类的资源
  2. 关于事件的处理一般都跟observer有关
  3. observer往往和责任链共同负责对事件的处理，其中的某一个observer负责决定是否将事件进一步传递（但无法往回传，责任链可以）