2. 程式人生 > >模組（類）之間解耦利器：EventPublishSubscribeUtils 事件釋出訂閱工具類

模組（類）之間解耦利器：EventPublishSubscribeUtils 事件釋出訂閱工具類

阿新 • • 發佈：2020-05-08
如果熟悉C#語言的小夥伴們一般都會知道委託、事件的好處，只需在某個類中提前定義好公開的委託或事件（委託的特殊表現形式）變數，然後在其它類中就可以很隨意的訂閱該委託或事件，當委託或事件被觸發執行時，會自動通知所有的訂閱者進行消費處理。（觀察者模式用委託來實現是最好不過了，DDD所提倡的事件驅動其根本理念也是如此），當然我這裡想到的是不需要在每個類中進行定義委託或事件，而是由一個統一的中介者（即EventPublishSubscribeUtils）來提供事件的訂閱及釋出操作，這樣各模組之間無需直接依賴，只需通過中介者完成釋出通知與訂閱回撥即可，何樂而不為呢？ 這裡我先借助C#語言獨有的委託型別快速實現了一個簡易的EventPublishSubscribeUtils，程式碼如下： ```c# /// /// 自定義事件釋出訂閱回撥工具類（業務解藕、關注點分離，避免互相依賴）--演示版 /// EventBus簡化版，觀察者模式 /// author:zuowenjun /// public static class EventPublishSubscribeUtils { private static ConcurrentDictionary> EventHandlers { get; } = new ConcurrentDictionary>(); private static void removeRegisters(ref EventHandler srcEvents, EventHandler removeTargetEvents) { var evtTypes = removeTargetEvents.GetInvocationList().Select(d => d.GetType()); var registeredEventHandlers = Delegate.Combine(srcEvents.GetInvocationList().Where(ei => evtTypes.Contains(ei.GetType())).ToArray()); srcEvents -= (EventHandler)registeredEventHandlers; } public static void Register(EventHandler eventHandlers) { EventHandlers.AddOrUpdate(typeof(T), eventHandlers, (t, e) => { //先根據訂閱委託型別匹匹配過濾掉之前已有的相同訂閱，然後再重新訂閱，防止重複訂閱，多次執行的情況。 removeRegisters(ref e, eventHandlers); e += eventHandlers; return e; }); } public static void UnRegister(EventHandler eventHandlers = null) { Type eventMsgType = typeof(T); if (eventHandlers == null) { EventHandlers.TryRemove(eventMsgType, out eventHandlers); return; } var e = EventHandlers[eventMsgType]; removeRegisters(ref e, eventHandlers); } public static void PublishEvent(T eventMsg, object sender) { Type eventMsgType = eventMsg.GetType(); if (EventHandlers.ContainsKey(eventMsgType)) { EventHandlers[eventMsgType].Invoke(sender, eventMsg); } } } ``` 然後使用就比較簡單了，我們只需通過EventPublishSubscribeUtils.Register註冊訂閱事件訊息，通過EventPublishSubscribeUtils.PublishEvent釋出事件通知，這樣就可以讓兩個甚至多個不相關的模組（類）能夠通過訊息型別實現1對多的通訊與協同處理。使用示例程式碼如下： ```c# class EventMessage { public string Name { get; set; } public string Msg { get; set; } public DateTime CreatedDate { get; set; } } class DemoA { public DemoA() { EventHandler eventHandlers = EventCallback1; eventHandlers += EventCallback2; EventPublishSubscribeUtils.Register(eventHandlers); } private void EventCallback1(object sender, object e) { string json = JsonConvert.SerializeObject(e); System.Diagnostics.Debug.WriteLine($"EventCallback1=> sender:{sender},e:{json}"); } private void EventCallback2(object sender, object e) { string json = JsonConvert.SerializeObject(e); System.Diagnostics.Debug.WriteLine($"EventCallback2=> sender:{sender},e:{json}"); } } class DemoB { public void ShowMsg(string name, string msg) { System.Diagnostics.Debug.WriteLine($"ShowMsg=> name:{name},msg:{msg}"); var eventMsg = new EventMessage { Name = name, Msg = msg, CreatedDate = DateTime.Now }; EventPublishSubscribeUtils.PublishEvent(eventMsg, nameof(DemoB.ShowMsg)); } } //main方法中使用： var demoA = new DemoA(); var demoB = new DemoB(); demoB.ShowMsg("夢在旅途", "i love csharp and java!"); ``` 從上述示例程式碼中可以看出，DemoA與DemoB各為獨立，互不依賴，它們都不知道有對方的存在，它們只關心業務的處理，通過執行demoB.ShowMsg方法進而觸發回撥demoA.EventCallback1，demoA.EventCallback2方法，是不是比起直接從DemoA中調DemoB更好呢？ c#有委託型別（方法的引用），那如果是在java中該如何實現呢？ 其實同理，我們可以藉助匿名內部類+匿名實現類的方式（如：函式式介面）實現與C#異曲同工的效果，同樣可以實現類似的事件釋出與訂閱功能，如下便是採用java語言的實現EventPublishSubscribeUtils類的程式碼： 這個因專案需要，我特意實現了兩種模式，一種支援1對多的普通方式，另一種支援1對1的訂閱回撥方式，有返回值。 ```java /** * 自定義事件釋出訂閱回撥工具類（業務解藕、關注點分離，避免互相依賴） * EventBus簡化版，觀察者模式 * 
 * 支援兩種模式
 * 1.無返回值：訂閱事件消費（register）+ 釋出事件訊息（publishEvent/publishEventAsync）
 * 2.有返回值：監聽回撥通知處理（listenCallback）+通知回撥（notifyCallback）,通過notifyMessageType+MessageChannel 即可標識唯一的一組通知回撥與監聽回撥處理
 * 
 * @author zuowenjun
 * @date 20200310
 */
public final class EventPublishSubscribeUtils {

    private static final Logger LOGGER = LoggerFactory.getLogger(EventPublishSubscribeUtils.class);

    private static final Map, LinkedList>> eventConsumers = new ConcurrentHashMap<>();

    private static final Map, ConcurrentHashMap>> callbackFuncs = new ConcurrentHashMap<>();

    private EventPublishSubscribeUtils() {
    }


    /**
     * 註冊事件回撥消費者
     * 用法：EventSubscribeConsumeUtils.register(this::xxxx方法） 或lambda表示式
     * 注意：若回撥方法添加了事務註解，則應指派其代理物件的方法來完成回撥，如：
     * EventSubscribeConsumeUtils.register((xxxService)SpringUtils.getBean(this.class)::xxxx方法）
     *
     * @param eventConsumer
     */
    public static void register(Class eventMessageType, Consumer eventConsumer) {

        if (eventConsumer == null) {
            return;
        }

        LinkedList> eventConsumerItems = null;
        if (!eventConsumers.containsKey(eventMessageType)) {
            eventConsumers.putIfAbsent(eventMessageType, new LinkedList<>());
        }
        eventConsumerItems = eventConsumers.get(eventMessageType);

        eventConsumerItems.add(eventConsumer);
    }

    /**
     * 取消訂閱回撥
     *
     * @param eventMessageType
     * @param eventConsumer
     */
    public static void unRegister(Class eventMessageType, Consumer eventConsumer) {
        if (!eventConsumers.containsKey(eventMessageType)) {
            return;
        }

        LinkedList> eventConsumerItems = eventConsumers.get(eventMessageType);
        int eventConsumerIndex = eventConsumerItems.indexOf(eventConsumer);
        if (eventConsumerIndex == -1) {
            return;
        }
        eventConsumerItems.remove(eventConsumerIndex);
    }


    /**
     * 釋出事件，同步觸發執行回撥事件消費者方法（存在阻塞等待），即事件訊息生產者
     * 用法：在需要觸發事件訊息回撥時呼叫，如：publishEvent(eventMessage);
     *
     * @param eventMessage
     */
    public static  void publishEvent(T eventMessage) {
        Class eventMessageType = eventMessage.getClass();

        if (!eventConsumers.containsKey(eventMessageType)) {
            return;
        }

        LOGGER.info("事件已釋出，正在執行通知消費:{}", JSONObject.toJSONString(eventMessage));

        for (Consumer eventConsumer : eventConsumers.get(eventMessageType)) {
            try {
                eventConsumer.accept(eventMessage);
            } catch (Exception ex) {
                LOGGER.error("eventConsumer.accept error:{},eventMessageType:{},eventMessage:{}",
                        ex, eventMessageType, JSONObject.toJSONString(eventMessage));
            }
        }
    }


    /**
     * 釋出事件，非同步觸發執行回撥事件消費者方法（非同步非阻塞），即事件訊息生產者
     * 用法：在需要觸發事件訊息回撥時呼叫，如：publishEventAsync(eventMessage);
     *
     * @param eventMessage
     */
    public static  void publishEventAsync(final T eventMessage) {
        Executor asyncTaskExecutor = (Executor) SpringUtils.getBean("asyncTaskExecutor");
        asyncTaskExecutor.execute(() -> {
            publishEvent(eventMessage);
        });
    }


    /**
     * 監聽回撥處理（需要有返回值），即有返回值的回撥消費者
     *
     * @param notifyMessageType
     * @param messageChannel
     * @param callbackFunc
     */
    public static void listenCallback(Class notifyMessageType, MessageChannel messageChannel, Function callbackFunc) {
        if (!callbackFuncs.containsKey(notifyMessageType)) {
            callbackFuncs.putIfAbsent(notifyMessageType, new ConcurrentHashMap<>());
        }

        Map> functionMap = callbackFuncs.get(notifyMessageType);
        if (!functionMap.containsKey(messageChannel)) {
            functionMap.putIfAbsent(messageChannel, callbackFunc);
        } else {
            LOGGER.error("該通知訊息型別：{}+訊息通道：{}，已被訂閱監聽，重複訂閱監聽無效！", notifyMessageType.getSimpleName(), messageChannel.getDescription());
        }

    }

    /**
     * 通知回撥（同步等待獲取監聽回撥的處理結果），即生產者
     *
     * @param notifyMessage
     * @param messageChannel
     * @param 
     * @return
     */
    @SuppressWarnings("unchecked")
    public static  R notifyCallback(Object notifyMessage, MessageChannel messageChannel) {
        Class notifyMessageType = notifyMessage.getClass();

        Map> functionMap = callbackFuncs.getOrDefault(notifyMessageType, null);
        if (functionMap != null) {
            Function callbackFunction = functionMap.getOrDefault(messageChannel, null);
            if (callbackFunction != null) {
                LOGGER.info("通知回撥訊息已釋出，正在執行回撥處理:{},messageChannel:[{}]", JSONObject.toJSONString(notifyMessage), messageChannel.getDescription());
                Object result = callbackFunction.apply(notifyMessage);
                try {
                    return (R) result;
                } catch (ClassCastException castEx) {
                    throw new ClassCastException(String.format("監聽回撥處理後返回值實際型別與釋出通知回撥待接收的值預期型別不一致，導致型別轉換失敗：%s," +
                                    "請確保notifyCallback與listenCallback針對通知訊息型別：%s+訊息通道：%s返回值型別必需一致。",
                            castEx.getMessage(), notifyMessageType.getSimpleName(), messageChannel.getDescription()));
                }

            }
        }
        return null;
    }


}
```

當然如果需要實現1對1的通訊，除了指定訊息型別外，還需要指定訊息通訊通道（即：唯一標識），目的是可以實現同一種訊息型別，支援不同的點對點的處理。

```java
/**
 * 自定義訊息通道
 * 作用：用於識別同一個訊息型別下不同的監聽回撥者（notifyMessage+messageChannel 即可標識唯一的一組通知回撥[生產者]與監聽回撥[消費者]）
 * @author zuowenjun
 * @date 2020-03-31
 */
public enum MessageChannel {
    None("無效"),
    MSG_A("測試訊息A"),
    ;

    private String description;

    MessageChannel(String description) {
        this.description=description;
    }

    public String getDescription() {
        return description;
    }
}
```

使用方法示例程式碼如下：

```java

@Service
public class DemoAService {

    private static final Logger LOGGER = LoggerFactory.getLogger(DemoAService.class);
    

    public void showMsg(String name, String msg) {
        System.out.printf("【%1$tF %1$tT.%1$tL】hello!%s,DemoAService showMsg:%s %n", new Date(), name, msg);

        EventMessage eventMessage = new EventMessage();
        eventMessage.setName("aaa");
        eventMessage.setMsg("test");
        eventMessage.setCreatedDate(new Date());
        EventPublishSubscribeUtils.publishEvent(eventMessage);

        String msgJsonStr = EventPublishSubscribeUtils.notifyCallback(eventMessage, MessageChannel.MSG_A);

        System.out.printf("【%1$tF %1$tT.%1$tL】DemoAService showMsg notifyCallback json result:%2$s %n", new Date(), msgJsonStr);
    }

}


@Service
public class DemoBService {

    @Autowired
    private DemoAService demoAService;

    @PostConstruct
    public void init(){

        //訂閱消費，無返回值，支援1對多，即：同一個訊息型別可同時被多個消費者訂閱
        EventPublishSubscribeUtils.register(EventMessage.class,this::showFinishedMsg);

        //訂閱監聽回撥，有返回值，只能1對1
        EventPublishSubscribeUtils.listenCallback(EventMessage.class, MessageChannel.MSG_A,this::getMsgCallbak);
    }

    private void showFinishedMsg(Object eventMsg){
        EventMessage eventMessage=(EventMessage)eventMsg;
        System.out.printf("【%1$tF %1$tT.%1$tL】%s,receive msg:%s doing...%n",
                eventMessage.getCreatedDate(),eventMessage.getName(),eventMessage.getMsg());

        //模擬邏輯處理
        try {
            Thread.sleep(500L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.printf("【%1$tF %1$tT.%1$tL】%s,do finished!!!%n",new Date(),eventMessage.getName());
    }

    private String getMsgCallbak(Object eventMsg){
        EventMessage eventMessage=(EventMessage)eventMsg;
        eventMessage.setMsg(eventMessage.getMsg()+"--callback added!");
        eventMessage.setCreatedDate(new Date());

        System.out.printf("【%1$tF %1$tT.%1$tL】%s,do msg callback!!!%n",new Date(),eventMessage.getName());

        return JSONObject.toJSONString(eventMessage);
    }

}


```

如上程式碼所示，我們藉助於EventPublishSubscribeUtils，解耦了兩個Service Bean之間的依賴，避免了迴圈依賴的問題，去掉了之前為了解決迴圈依賴而使用@Lazy註解的方式，更易於擴充套件與更改。其實Spring底層也使用了類似的Event機制,說明這種方式還是有合適的用武之地的。

這裡我通過簡單的關係圖來對比未引用EventPublishSubscribeUtils前與引用後的區別，大家可以感受一下哪種更方便：
之前：
![](https://img2020.cnblogs.com/blog/458152/202005/458152-20200507210130961-1512376505.png)

之後：
![](https://img2020.cnblogs.com/blog/458152/202005/458152-20200507210229695-1766866105.png)



最後，關於業務解耦，分清業務邊界，我個人認為跨程序通訊使用MQ，同進程跨多模組（類，或者說跨多業務邊界）可使用Event事件驅動思路來解決。大家覺得如何呢？如果有更好的方案歡迎評論交流，   
 
  
 

            
  

           

              
              

            

            
相關推薦

			   
            
            
            
 

    


    
    
模組（類）之間解耦利器：EventPublishSubscribeUtils 事件釋出訂閱工具類

     
 如果熟悉C#語言的小夥伴們一般都會知道委託、事件的好處，只需在某個類中提前定義好公開的委託或事件（委託的特殊表現形式）變數，然後在其它類中就可以很隨意的訂閱該委託或事件，當委託或事件被觸發執行時，會自動通知所有的訂閱者進行消費處理。（觀察者模式用委託來實現是最好不過了，DDD所提倡的事件驅動其根本理念也是如此 



  
 

    


    
    
iOS 程式碼解耦利器（一）

     
 
							
							
							最近寫demo的過程中需要通過tableView的cell跳轉到多個頁面，當時偷懶不想去引用標頭檔案了，靈光一閃，寫了一個跳轉的方法，後來自己有完善了一下，基本滿足了不帶引數的頁面跳轉，帶引數的頁面跳轉（使用者自定義的物件也是可以的）。
下面就給大家簡單的講一下 



  
 

    


    
    
GoLang基礎數據類型--->字典（map）詳解

     
 golang   ont   nbsp   spa   數據   否則   創作   聲明   作者   　　　　　　　　　　　　　　　　　　　　　　　　 GoLang基礎數據類型--->字典（map）詳解
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 



  
 

    


    
    
Kotlin——最詳細的抽象類（abstract）、內部類（嵌套類）詳解

     
 unit   建議   git   功能   pen   情況   master   這也   html   
在前面幾個章節中，詳細的介紹了Kotlin類的類別中的數據類、密封類、接口類以及枚舉類。在這個章節中會對Koltin的抽象類和內部類作出一個詳細的講解。如果對上面所提到的類的類別還不是很清晰的，請閱 



  
 

    


    
    
設計模式：觀察者模式（有利於代碼解耦）

     
 attribute   處理   script   refresh   含義   復制   重新   ecif   nec   什麽是ApplicationContext? 它是Spring的核心，Context我們通常解釋為上下文環境，但是理解成容器會更好些。 ApplicationContext則是應用的 



  
 

    


    
    
Guava - EventBus(事件匯流排) - 事件釋出訂閱模式（一對多、同一個JVM下解耦）

     
  
 
 原文：https://www.cnblogs.com/whitewolf/p/4132840.html 
 Guava在guava-libraries中為我們提供了事件匯流排EventBus庫，它是事件釋出訂閱模式的實現，讓我們能在領域驅動設計(DDD)中以事件的弱引用本質對我們的模組和領域邊界很好 



  
 

    


    
    
4. 首頁模組（二）之工具類

     
  
  
  
 上一節對歡迎模組進行了綜述(可參見 2. 歡迎模組 進行了解)，接下來將從首頁模組開始詳細介紹： 
  
  [首頁模組（一）之搭建伺服器] 
  [首頁模組（二）之工具類] 
  [首頁模組（三）之首頁] 
  [首頁模組（四）之新聞詳情] 
  [首頁模組（五）之Python學科] 
  



  
 

    


    
    
python標準庫常用模組（一）-----------------------------time模組詳解及相關演示程式碼

     
 
                要想了解time模組，我們需要首先了解一下時間的三種表現形式：

1.時間戳：當前距離1970年的秒數

2.格式化的字串：即2018年9月11日的這種表現形式

3.struct_time:元組時間，以元組的形式顯示時間，一共有九個元素

下面來介紹一下它具體的方法及示例程 



  
 

    


    
    
python標準庫常用模組（三）-----------------------------OS模組詳解，呼叫系統的命令

     
 
                OS模組是呼叫系統命令的模組，和執行cmd的命令相似。

1.獲取當前的工作目錄：getcwd()

2.改變當前指令碼的工作目錄：chdir(path)

3.返回當前目錄：curdir()

4.獲取當前目錄的父目錄：pardir()

5.若目錄為空，則刪除，遞迴到上一 



  
 

    


    
    
Apache學習---多程序處理模組（MPM）原理詳解

     
   
  
  
  
  
檢視Apache的模式，可以使用httpd -V命令來檢視： 
1. prefork MPM 
prefork模式可以算是很古老但是非常穩定的Apache模式。Apache在啟動之初，就預先fork一些子程序，然後等待請求進來。之 



  
 

    


    
    
Eclipse使用（十二）—— 建立Maven多模組（父子）專案演示Maven的聚合和繼承以及模組之間的依賴關係

     
 

在子模組中宣告該模組所屬的父專案，如下：
<packaging>jar</packaging><!-- 打包方式jar包或者war包，如果不宣告預設為jar包，當然也可以為pom，這意味著此模組下面還有子模組 -->
<parent> 
  <grou 



  
 

    


    
    
類（物件）之間的四種關係。

     
 
                
類（物件）之間的4種關係
   a、依賴關係（Dependency）
    所謂依賴就是某個物件的功能依賴於另外的某個物件，而被依賴的物件只是作為一種工具在使用，而並不持有對它的引用
    舉例：一個人自創生就需要不停的呼吸，而人的呼吸功能之所以能維持生命就在於吸進來的 



  
 

    


    
    
Jmeter系列（43）- 詳解 Jmeter 圖形化 HTML 壓測報告之 Charts 模組

     
 如果你想從頭學習Jmeter，可以看看這個系列的文章哦
https://www.cnblogs.com/poloyy/category/1746599.html
 
前言
可以搭配上一篇部落格來看哦，是一個整體內容：https://www.cnblogs.com/poloyy/p/13278920. 



  
 

    


    
    
HTTP協議（一）——了解Web及網絡基礎

     
 協議   http   web   一、使用HTTP協議訪問Web    Web頁面不會憑空顯示出來，根據Web瀏覽器地址欄中指定的URL，Web瀏覽器從Web服務器獲取文件資源等信息，從而顯示出Web頁面。    像這種通過發送請求獲取服務器資源的Web瀏覽器等，都可稱為客戶端。本文出自 “IT菜鳥” 博客 



  
 

    


    
    
Java中long（Long）與int（Integer）之間的轉換（轉）

     
 轉化   string   long   tar   str   基礎數據類型   ava   detail   參考   一、將long型轉化為int型，這裏的long型是基礎類型：

long   a = 10;     int b = (int)a;   

二、將Long型轉換為int型，這裏 



  
 

    


    
    
Vue.js（一）了解Vue

     
 code   視圖   模式   data   img   app   了解   eight   整合   什麽是Vue？
1.Vue.js是一個構建數據驅動的web界面的庫。類似於Angularjs，在技術上，他重點集中在MVVM模式的View層，非常容易學習，非常容易和其他的庫或已有的項目整合。
2.Vu 



  
 

    


    
    
SQL語句之數據定義語言（DDL）詳解

     
 三種   absolute   row   redundant   字符   對象   not null   工作   part   操作對象：數據庫
1）創建數據庫
MariaDB [(none)]> help create databaseName: ‘CREATE DATABASE‘Descrip 



  
 

    


    
    
指標詳解（1）--   軌道線指標（ENE）詳解

     
 本質   平均值   width   簡單   公式   方向   重新   alt   改變   軌道線指標（ENE）：
 
1、定義：軌道線（ENE）由上軌線(UPPER)和下軌線(LOWER)及中軌線(ENE)組成，軌道線的優勢在於其不僅具有趨勢軌道的研判分析作用，也可以敏銳的覺察股價運行過程中方向的改 



  
 

    


    
    
指標詳解（5）-- 布林線指標（BOLL）詳解

     
 tar   線下   pan   evel   隨著   向上   log   link   bsp   一、定義：布林線指標，即BOLL指標，其英文全稱是“Bollinger Bands”，布林線(BOLL)由約翰·布林先生創造，其利用統計原理，求出股價的標準差及其信賴區間，從而確定股價的波動範圍及未來走勢 



  
 

    


    
    
Android OpenGL ES 入門系列（一） --- 了解OpenGL ES的前世今生

     
 target   初始化   vertex   單獨   http   hang   tex   變化   3d圖    
轉載請註明出處
本文出自Hansion的博客
OpenGL ES (OpenGL for Embedded Systems)
        是 OpenGL 三維圖形 API 的子集，