观察者模式的应用场景

观察者模式（Observer Pattern）定义了对象之间的一对多依赖，让多个观察者对象同时监听一个主体对象，当主体对象发生变化时，它的所有以依赖者（观察者）都会受到通知并更新，属于行为型模式。

观察者模式有时也叫作发布订阅模式。观察者模式主要用于在关联行为之间建立一套触发机制的场景。观察者模式在现实生活应用得也非常广泛，比如微信朋友圈动态通知、页面的消息通知、邮件通知、广播通知等。

JDK API

当“小伙伴们”在 GPer 生态圈中提问的时候，如果设置了指定老师回答，对应的老师就会收到邮件通知，这就是观察者模式的一种应用场景。其实 JDK 本身就提供了这样的 API。我们用代码来还原一下这个应用场景，创建 GPer 类：

  1. package com.yjw.demo.pattern.observer.GPer_java;
  3. import java.util.Observable;
  5. public class GPer extends Observable {
  7.     private String name = "GPer 生态圈";
  8.     private static GPer gper = null;
  10.     private GPer() {
  11.     }
  13.     public static GPer getInstance() {
  14.         if (null == gper) {
  15.             gper = new GPer();
  16.         }
  17.         return gper;
  18.     }
  20.     public String getName() {
  21.         return name;
  22.     }
  24.     public void publishQuestion(Question question) {
  25.         System.out.println(question.getUserName() + "在" + this.name + "上提交了一个问题。");
  26.         setChanged();
  27.         notifyObservers(question);
  28.     }
  29. }

创建文体类 Question：

  1. package com.yjw.demo.pattern.observer.GPer_java;
  3. public class Question {
  5.     private String userName;
  6.     private String content;
  8.     public String getUserName() {
  9.         return userName;
  10.     }
  12.     public void setUserName(String userName) {
  13.         this.userName = userName;
  14.     }
  16.     public String getContent() {
  17.         return content;
  18.     }
  20.     public void setContent(String content) {
  21.         this.content = content;
  22.     }
  23. }

创建老师类 Teacher：

  1. package com.yjw.demo.pattern.observer.GPer_java;
  3. import java.util.Observable;
  4. import java.util.Observer;
  6. public class Teacher implements Observer {
  8.     private String name;
  10.     public Teacher(String name) {
  11.         this.name = name;
  12.     }
  14.     @Override
  15.     public void update(Observable o, Object arg) {
  16.         GPer gper = (GPer) o;
  17.         Question question = (Question) arg;
  18.         System.out.println("========================");
  19.         System.out.println(name + "老师，你好！\n" + "您收到了一个来自“" + gper.getName()
  20.                 + "”的提问，希望您解答，问题内容如下：\n" + question.getContent()
  21.                 + "\n" + "提问者：" + question.getUserName());
  22.     }
  23. }

客户端测试代码如下：

  1. package com.yjw.demo.pattern.observer.GPer_java;
  3. public class ObserverTest {
  4.     public static void main(String[] args) {
  5.         GPer gper = GPer.getInstance();
  6.         Teacher tom = new Teacher("Tom");
  7.         Teacher mic = new Teacher("Mic");
  9.         gper.addObserver(tom);
  10.         gper.addObserver(mic);
  12.         // 业务逻辑代码
  13.         Question question = new Question();
  14.         question.setUserName("小明");
  15.         question.setContent("观察者设计模式适用于哪些场景？");
  17.         gper.publishQuestion(question);
  18.     }
  19. }

运行结果如下图所示。

image.png

手动实现

为了更加深刻地了解观察者模式的实现原理，我们设计一个监听鼠标事件的观察者模式。

首先，创建 Event 类：

  1. package com.yjw.demo.pattern.observer.mouse.core;
  3. import java.lang.reflect.Method;
  5. /**
  6.  * 事件内容
  7.  */
  8. public class Event {
  10.     // 事件源，事件由谁发起的，保存起来
  11.     private Object source;
  12.     // 事件触发，要通知谁
  13.     private Object target;
  14.     // 事件触发，要做什么动作，回调
  15.     private Method callback;
  16.     // 事件的名称，触发是什么事件
  17.     private String trigger;
  18.     // 事件触发的时间
  19.     private long time;
  21.     public Event(Object target, Method callback) {
  22.         super();
  23.         this.target = target;
  24.         this.callback = callback;
  25.     }
  27.     public Object getSource() {
  28.         return source;
  29.     }
  31.     public void setSource(Object source) {
  32.         this.source = source;
  33.     }
  35.     public Object getTarget() {
  36.         return target;
  37.     }
  39.     public void setTarget(Object target) {
  40.         this.target = target;
  41.     }
  43.     public Method getCallback() {
  44.         return callback;
  45.     }
  47.     public void setCallback(Method callback) {
  48.         this.callback = callback;
  49.     }
  51.     public String getTrigger() {
  52.         return trigger;
  53.     }
  55.     public void setTrigger(String trigger) {
  56.         this.trigger = trigger;
  57.     }
  59.     public long getTime() {
  60.         return time;
  61.     }
  63.     public void setTime(long time) {
  64.         this.time = time;
  65.     }
  67.     @Override
  68.     public String toString() {
  69.         return "Event{" +
  70.                 "source=" + source +
  71.                 ", target=" + target +
  72.                 ", callback=" + callback +
  73.                 ", trigger='" + trigger + '\'' +
  74.                 ", time=" + time +
  75.                 '}';
  76.     }
  77. }

创建 EventLisenter 类：

  1. package com.yjw.demo.pattern.observer.mouse.core;
  3. import java.lang.reflect.Method;
  4. import java.util.HashMap;
  5. import java.util.Map;
  7. /**
  8.  * 监听器，它就是观察者的桥梁
  9.  */
  10. public class EventListener {
  12.     // JDK 底层的Listener通常也是这样设计的
  13.     private Map<String, Event> events = new HashMap<>();
  15.     /**
  16.      * 添加事件监听
  17.      *
  18.      * @param eventType
  19.      * @param target
  20.      */
  21.     public void addListener(String eventType, Object target) {
  22.         try {
  23.             this.addListener(eventType, target,
  24.                     target.getClass().getMethod("on" + toUpperFirstCase(eventType), Event.class));
  25.         } catch (NoSuchMethodException e) {
  26.             e.printStackTrace();
  27.         }
  28.     }
  30.     public void addListener(String eventType, Object target, Method callback) {
  31.         // 注册事件
  32.         events.put(eventType, new Event(target, callback));
  33.     }
  35.     /**
  36.      * 触发事件
  37.      *
  38.      * @param event
  39.      */
  40.     public void trigger(Event event) {
  41.         event.setSource(this);
  42.         event.setTime(System.currentTimeMillis());
  44.         try {
  45.             // 发起回调
  46.             if (event.getCallback() != null) {
  47.                 event.getCallback().invoke(event.getTarget(), event);
  48.             }
  49.         } catch (Exception e) {
  50.             e.printStackTrace();
  51.         }
  52.     }
  54.     /**
  55.      * 触发事件
  56.      *
  57.      * @param trigger
  58.      */
  59.     protected void trigger(String trigger) {
  60.         if (!this.events.containsKey((trigger))) {
  61.             return;
  62.         }
  63.         trigger(this.events.get(trigger).setTrigger(trigger));
  64.     }
  66.     private String toUpperFirstCase(String str) {
  67.         char[] chars = str.toCharArray();
  68.         chars[0] -= 32;
  69.         return String.valueOf(chars);
  70.     }
  72. }

创建 MouseEventType 接口：

  1. package com.yjw.demo.pattern.observer.mouse;
  3. /**
  4.  * 鼠标事件类型
  5.  */
  6. public interface MouseEventType {
  7.     // 单击
  8.     String ON_CLICK = "click";
  10.     // 双击
  11.     String ON_DOUBLE_CLICK = "doubleClick";
  13.     // 弹起
  14.     String ON_UP = "up";
  16.     // 按下
  17.     String ON_DOWN = "down";
  19.     // 移动
  20.     String ON_MOVE = "move";
  22.     // 滚动
  23.     String ON_WHEEL = "wheel";
  25.     // 悬停
  26.     String ON_OVER = "over";
  28.     // 失焦
  29.     String ON_BLUR = "blur";
  31.     // 获焦
  32.     String ON_FOCUS = "focus";
  33. }

创建 Mouse 类：

  1. package com.yjw.demo.pattern.observer.mouse;
  3. import com.yjw.demo.pattern.observer.mouse.core.EventListener;
  5. /**
  6.  * 鼠标
  7.  *
  8.  * <pre>
  9.  * 通常的话，采用动态代理来实现监控，避免了代码侵入
  10.  * </pre>
  11.  *
  12.  * @author yinjianwei
  13.  * @date 2019/01/04
  14.  */
  15. public class Mouse extends EventListener {
  17.     public void click() {
  18.         System.out.println("调用单击方法");
  19.         trigger(MouseEventType.ON_CLICK);
  20.     }
  22.     public void doubleClick() {
  23.         System.out.println("调用双击方法");
  24.         trigger(MouseEventType.ON_DOUBLE_CLICK);
  25.     }
  27.     public void up() {
  28.         System.out.println("调用弹起方法");
  29.         trigger(MouseEventType.ON_UP);
  30.     }
  32.     public void down() {
  33.         System.out.println("调用按下方法");
  34.         trigger(MouseEventType.ON_DOWN);
  35.     }
  37.     public void move() {
  38.         System.out.println("调用移动方法");
  39.         trigger(MouseEventType.ON_MOVE);
  40.     }
  42.     public void wheel() {
  43.         System.out.println("调用滚动方法");
  44.         trigger(MouseEventType.ON_WHEEL);
  45.     }
  47.     public void over() {
  48.         System.out.println("调用悬停方法");
  49.         trigger(MouseEventType.ON_OVER);
  50.     }
  52.     public void blur() {
  53.         System.out.println("调用失焦方法");
  54.         trigger(MouseEventType.ON_BLUR);
  55.     }
  57.     public void focus() {
  58.         System.out.println("调用获焦方法");
  59.         trigger(MouseEventType.ON_FOCUS);
  60.     }
  61. }

创建 MouseEventCallback 类：

  1. package com.yjw.demo.pattern.observer.mouse;
  3. import com.yjw.demo.pattern.observer.mouse.core.Event;
  5. /**
  6.  * 观察者，观察鼠标动作
  7.  *
  8.  * @author yinjianwei
  9.  * @date 2019/01/04
  10.  */
  11. public class MouseEventCallback {
  13.     public void onClick(Event event) {
  14.         System.out.println("==========触发鼠标单击事件==========" + "\n" + event);
  15.     }
  17.     public void onDoubleClick(Event event) {
  18.         System.out.println("==========触发鼠标双击事件==========" + "\n" + event);
  19.     }
  21.     public void onUp(Event event) {
  22.         System.out.println("==========触发鼠标弹起事件==========" + "\n" + event);
  23.     }
  25.     public void onDown(Event event) {
  26.         System.out.println("==========触发鼠标按下事件==========" + "\n" + event);
  27.     }
  29.     public void onMove(Event event) {
  30.         System.out.println("==========触发鼠标移动事件==========" + "\n" + event);
  31.     }
  33.     public void onWheel(Event event) {
  34.         System.out.println("==========触发鼠标滚动事件==========" + "\n" + event);
  35.     }
  37.     public void onOver(Event event) {
  38.         System.out.println("==========触发鼠标悬停事件==========" + "\n" + event);
  39.     }
  41.     public void onBlur(Event event) {
  42.         System.out.println("==========触发鼠标失焦事件==========" + "\n" + event);
  43.     }
  45.     public void onFocus(Event event) {
  46.         System.out.println("==========触发鼠标获焦事件==========" + "\n" + event);
  47.     }
  48. }

客户端测试代码如下：

  1. package com.yjw.demo.pattern.observer.mouse;
  3. import java.lang.reflect.Method;
  5. import com.yjw.demo.pattern.observer.mouse.core.Event;
  7. /**
  8.  * 鼠标事件测试
  9.  *
  10.  * @author yinjianwei
  11.  * @date 2019/01/04
  12.  */
  13. public class MouseEventTest {
  14.     public static void main(String[] args) {
  15.         try {
  16.             MouseEventCallback mouseEventCallback = new MouseEventCallback();
  18.             // 注册事件
  19.             Mouse mouse = new Mouse();
  20.             mouse.addListener(MouseEventType.ON_CLICK, mouseEventCallback);
  21.             mouse.addListener(MouseEventType.ON_DOUBLE_CLICK, mouseEventCallback);
  22.             mouse.addListener(MouseEventType.ON_UP, mouseEventCallback);
  23.             mouse.addListener(MouseEventType.ON_DOWN, mouseEventCallback);
  24.             mouse.addListener(MouseEventType.ON_MOVE, mouseEventCallback);
  25.             mouse.addListener(MouseEventType.ON_WHEEL, mouseEventCallback);
  26.             mouse.addListener(MouseEventType.ON_OVER, mouseEventCallback);
  27.             mouse.addListener(MouseEventType.ON_BLUR, mouseEventCallback);
  28.             mouse.addListener(MouseEventType.ON_FOCUS, mouseEventCallback);
  30.             // 调用方法
  31.             mouse.click();
  32.             mouse.doubleClick();
  33.         } catch (Exception e) {
  34.             e.printStackTrace();
  35.         }
  36.     }
  37. }

运行结果如下图所示。

image.png

观察者模式的优缺点

观察者模式的优点如下：

  1. 在观察者和被观察者之间建立了一个抽象的耦合。
  2. 观察者模式支持广播通信。

观察者模式的缺点如下：

  1. 观察者之间有过多的细节依赖、时间消耗多，程序的复杂性更高。
  2. 使用不当会出现循环调用。

摘录：《Spring 5 核心原理与30个类手写实战》来自文艺界的Tom老师的书籍。

作者：殷建卫 链接：https://www.yuque.com/yinjianwei/vyrvkf/hfzxhi 来源：殷建卫 - 架构笔记 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。