Design Pattern - Dispatcher Pattern

-

 

Dispatcher Pattern

上一篇聊了👉 Design Pattern - Observer Pattern

为了后续继续聊 Java IO-Netty，再谈下事件分发模式(Dispatcher Pattern)

定义

事件分发模式(Dispatcher Pattern) 模式是一种行为设计模式，用于将客户端的请求委托给多个不同的处理程序中的一个。该模式允许你将请求的处理逻辑与请求的接收逻辑分离，从而提高代码的可维护性和可扩展性。

Dispatcher模式详解

Dispatcher模式通常包含以下几个关键组件：

  • Dispatcher：负责接收请求并将其委托给相应的处理程序。
  • Event：定义请求的接口，通常包含一个执行方法。
  • ConcreteEvent：Event接口的具体实现，每个实现对应一个具体的处理程序。
  • EventListener：执行与请求相关的实际工作。

类图

示例代码

  1. // 事件类型，可以根据需要扩展
  2. public interface Event {
  4.     String getEventType();
  5. }
  6. // 定义事件监听器接口
  7. public interface EventListener {
  8.     void onEvent(Event event);
  9. }
  11. //Dispatcher类，用于注册监听器和分发事件
  12. import java.util.HashMap;
  13. import java.util.Map;
  14. public class EventDispatcher {
  16.     private Map<String, EventListener> listeners = new HashMap<>();
  18.     public void registerListener(String eventType, EventListener listener) {
  19.         listeners.put(eventType, listener);
  20.     }
  22.     public void dispatchEvent(Event event) {
  23.         EventListener listener = listeners.get(event.getEventType());
  24.         if (listener != null) {
  25.             listener.onEvent(event);
  26.         } else {
  27.             System.out.println("No listener for event: " + event.getEventType());
  28.         }
  29.     }
  30. }
  33. // 创建具体的事件类
  34. public class ConcreteEvent implements Event {
  35.     private String eventType;
  36.     private Object data;
  38.     public ConcreteEvent(String eventType, Object data) {
  39.         this.eventType = eventType;
  40.         this.data = data;
  41.     }
  43.     @Override
  44.     public String getEventType() {
  45.         return eventType;
  46.     }
  48.     public Object getData() {
  49.         return data;
  50.     }
  51. }
  52. //创建具体的事件监听器
  53. public class ConcreteEventListener implements EventListener {
  54.     private String listenerType;
  56.     public ConcreteEventListener(String type) {
  57.         this.listenerType = type;
  58.     }
  60.     @Override
  61.     public void onEvent(Event event) {
  62.         if (event.getEventType().equals(listenerType)) {
  63.             // 处理事件
  64.             System.out.println("Handling event: " + event.getEventType());
  65.             // 可以访问事件的数据
  66.             System.out.println("Event data: " + ((ConcreteEvent) event).getData());
  67.         }
  68.     }
  69. }
  71. //演示整个Dispatcher模式的运作
  72. public class DispatcherDemo {
  73.     public static void main(String[] args) {
  75.         EventDispatcher dispatcher = new EventDispatcher();
  77.         // 创建事件
  78.         Event event1 = new ConcreteEvent("TYPE1", "Data for TYPE1");
  79.         Event event2 = new ConcreteEvent("TYPE2", "Data for TYPE2");
  81.         // 创建监听器
  82.         EventListener listener1 = new ConcreteEventListener("TYPE1");
  83.         EventListener listener2 = new ConcreteEventListener("TYPE2");
  85.         // 注册监听器
  86.         dispatcher.registerListener("TYPE1", listener1);
  87.         dispatcher.registerListener("TYPE2", listener2);
  90.         // 分发事件
  91.         dispatcher.dispatchEvent(event1);
  92.         dispatcher.dispatchEvent(event2);
  93.     }
  94. }

总结

观察者模式(Observer Pattern)是一种特殊的事件分发模式(Dispatcher Pattern)

相同点

  1. 两者都解耦合 避免对象之间直接依赖。
  2. 两者都动态通讯 不要知道彼此的存在
  3. 两者都有注册机制

不同点

  1. 观察者模式(Observer Pattern) 1对多。一个特殊事件对所有的观察者。 1 To All
  2. 事件分发模式(Dispatcher Pattern) 多对多。多个正常事件对应多个接收者。
  3. 实现方式上：观察者模式(Observer Pattern) 有主题和观察者，事件分发模式(Dispatcher Pattern) 有 事件、分发器和接受者。可以将观察者模式(Observer Pattern) 中的事件看作为一个特殊的事件，因此内涵在观察者模式(Observer Pattern) 的主题中，观察者模式(Observer Pattern) 的主题等于特殊的事件+特殊的分发器

怎么做(How To)

如果数据量大分发器响应不过来了，接收者处理不过来了怎么办？😅

为了优化分发器，需要考虑的内容？阻塞、非阻塞、同步、异步？😅

为了优化接收者，需要考虑的内容？阻塞、非阻塞、同步、异步？😅

两者如何更好的配合？那就加上线程和IO往上干😂😂



Location: 中国广东省