2. 程式人生 > >Spring事件驅動模型詳解

Spring事件驅動模型詳解

阿新 • • 發佈：2019-01-21

事件驅動模型簡介

事件驅動模型也就是我們常說的觀察者，或者釋出-訂閱模型；理解它的幾個關鍵點：

  1. 首先是一種物件間的一對多的關係；最簡單的如交通訊號燈，訊號燈是目標（一方），行人注視著訊號燈（多方）；
  2. 當目標傳送改變（釋出），觀察者（訂閱者）就可以接收到改變；
  3. 觀察者如何處理（如行人如何走，是快走/慢走/不走，目標不會管的），目標無需干涉；所以就鬆散耦合了它們之間的關係。

接下來先看一個使用者註冊的例子：



使用者註冊成功後，需要做這麼多事：

1、加積分

2、發確認郵件

3、如果是遊戲帳戶，可能贈送遊戲大禮包

4、索引使用者資料

…………

問題：

  1. UserService和其他Service耦合嚴重，增刪功能比較麻煩；
  2. 有些功能可能需要呼叫第三方系統，如增加積分/索引使用者，速度可能比較慢，此時需要非同步支援；這個如果使用Spring，可以輕鬆解決，後邊再介紹；

從如上例子可以看出，應該使用一個觀察者來解耦這些Service之間的依賴關係，如圖：


增加了一個Listener來解耦UserService和其他服務，即註冊成功後，只需要通知相關的監聽器，不需要關係它們如何處理。增刪功能非常容易。

這就是一個典型的事件處理模型/觀察者，解耦目標物件和它的依賴物件，目標只需要通知它的依賴物件，具體怎麼處理，依賴物件自己決定。比如是非同步還是同步，延遲還是非延遲等。

上邊其實也使用了DIP（依賴倒置原則），依賴於抽象，而不是具體。

還是就是使用了IoC思想，即以前主動去建立它依賴的Service，現在只是被動等待別人註冊進來。

其他的例子還有如GUI中的按鈕和動作的關係，按鈕和動作本身都是一種抽象，每個不同的按鈕的動作可能不一樣；如“檔案-->新建”開啟新建視窗；點選“關閉”按鈕關閉視窗等等。

主要目的是：鬆散耦合物件間的一對多的依賴關係，如按鈕和動作的關係；

如何實現呢？面向介面程式設計（即面向抽象程式設計），而非面向實現。即按鈕和動作可以定義為介面，這樣它倆的依賴是最小的（如在Java中，沒有比介面更抽象的了）。

有朋友會問，我剛開始學的時候也是這樣：抽象類不也行嗎？記住一個原則：介面目的是抽象，抽象類目的是複用；所以如果接觸過servlet/struts2/spring等框架，大家都應該知道：

  • Servlet<-----GenericServlet<-----HttpServlet<------我們自己的
  • Action<------ActionSupport<------我們自己的
  • DaoInterface<------××DaoSupport<-----我們自己的

從上邊大家應該能體會出介面、抽象類的主要目的了。現在想想其實很簡單。

在Java中介面還一個非常重要的好處：介面是可以多實現的，類/抽象類只能單繼承，所以使用介面可以非常容易擴充套件新功能（還可以實現所謂的mixin），類/抽象類辦不到。

Java GUI事件驅動模型/觀察者 

扯遠了，再來看看Java GUI世界裡的事件驅動模型吧：

如果寫過AWT/Swing程式，應該知道其所有元件都繼承自java.awt.Component抽象類，其內部提供了addXXXListener(XXXListener l) 註冊監聽器的方法，即Component與實際動作之間依賴於XXXListener抽象。

比如獲取焦點事件，很多元件都可以有這個事件，是我們知道元件獲取到焦點後需要一個處理，雖然每個元件如何處理是特定的（具體的），但我們可以抽象一個FocusListener，讓所有具體實現它然後提供具體動作，這樣元件只需依賴於FocusListener抽象，而不是具體。

還有如java.awt.Button，提供了一個addActionListener(ActionListener l)，用於註冊點選後觸發的ActionListener實現。

元件是一個抽象類，其好處主要是複用，比如複用這些監聽器的觸發及管理等。

JavaBean規範的事件驅動模型/觀察者

JavaBean規範提供了JavaBean的PropertyEditorSupport及PropertyChangeListener支援。

PropertyEditorSupport就是目標，而PropertyChangeListener就是監聽器，大家可以google搜尋下，具體網上有很多例子。

Java提供的事件驅動模型/觀察者抽象

JDK內部直接提供了觀察者模式的抽象：

目標：java.util.Observable，提供了目標需要的關鍵抽象：addObserver/deleteObserver/notifyObservers()等，具體請參考javadoc。

觀察者：java.util.Observer，提供了觀察者需要的主要抽象：update(Observable o, Object arg)，此處還提供了一種推模型（目標主動把資料通過arg推到觀察者）/拉模型（目標需要根據o自己去拉資料，arg為null）。

因為網上介紹的非常多了，請google搜尋瞭解如何使用這個抽象及推/拉模型的優缺點。

接下來是我們的重點：spring提供的事件驅動模型。

Spring提供的事件驅動模型/觀察者抽象

首先看一下Spring提供的事件驅動模型體系圖： 

事件

具體代表者是：ApplicationEvent：

1、其繼承自JDK的EventObject，JDK要求所有事件將繼承它，並通過source得到事件源，比如我們的AWT事件體系也是繼承自它；

2、系統預設提供瞭如下ApplicationEvent事件實現：


只有一個ApplicationContextEvent，表示ApplicationContext容器事件，且其又有如下實現：

  • ContextStartedEvent：ApplicationContext啟動後觸發的事件；（目前版本沒有任何作用）
  • ContextStoppedEvent：ApplicationContext停止後觸發的事件；（目前版本沒有任何作用）
  • ContextRefreshedEvent：ApplicationContext初始化或重新整理完成後觸發的事件；（容器初始化完成後呼叫）
  • ContextClosedEvent：ApplicationContext關閉後觸發的事件；（如web容器關閉時自動會觸發spring容器的關閉，如果是普通java應用，需要呼叫ctx.registerShutdownHook();註冊虛擬機器關閉時的鉤子才行）

注：org.springframework.context.support.AbstractApplicationContext抽象類實現了LifeCycle的start和stop回撥併發布ContextStartedEvent和ContextStoppedEvent事件；但是無任何實現呼叫它，所以目前無任何作用。

目標（釋出事件者）

具體代表者是：ApplicationEventPublisher及ApplicationEventMulticaster，系統預設提供瞭如下實現：

1、ApplicationContext介面繼承了ApplicationEventPublisher，並在AbstractApplicationContext實現了具體程式碼，實際執行是委託給ApplicationEventMulticaster（可以認為是多播）：

Java程式碼  收藏程式碼
  1. public void publishEvent(ApplicationEvent event) {  
  2.     //省略部分程式碼  
  3.     }  
  4.     getApplicationEventMulticaster().multicastEvent(event);  
  5.     if (this.parent != null) {  
  6.         this.parent.publishEvent(event);  
  7.     }  
  8. }  

我們常用的ApplicationContext都繼承自AbstractApplicationContext，如ClassPathXmlApplicationContext、XmlWebApplicationContext等。所以自動擁有這個功能。

2、ApplicationContext自動到本地容器裡找一個名字為”“的ApplicationEventMulticaster實現，如果沒有自己new一個SimpleApplicationEventMulticaster。其中SimpleApplicationEventMulticaster釋出事件的程式碼如下：

Java程式碼  收藏程式碼
  1. public void multicastEvent(final ApplicationEvent event) {  
  2.     for (final ApplicationListener listener : getApplicationListeners(event)) {  
  3.         Executor executor = getTaskExecutor();  
  4.         if (executor != null) {  
  5.             executor.execute(new Runnable() {  
  6.                 public void run() {  
  7.                     listener.onApplicationEvent(event);  
  8.                 }  
  9.             });  
  10.         }  
  11.         else {  
  12.             listener.onApplicationEvent(event);  
  13.         }  
  14.     }  
  15. }  

 大家可以看到如果給它一個executor（java.util.concurrent.Executor），它就可以非同步支援釋出事件了。佛則就是通過傳送。

所以我們傳送事件只需要通過ApplicationContext.publishEvent即可，沒必要再建立自己的實現了。除非有必要。 

監聽器

具體代表者是：ApplicationListener

1、其繼承自JDK的EventListener，JDK要求所有監聽器將繼承它，比如我們的AWT事件體系也是繼承自它；

2、ApplicationListener介面：

Java程式碼  收藏程式碼
  1. public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {  
  2.     void onApplicationEvent(E event);  
  3. }  

其只提供了onApplicationEvent方法，我們需要在該方法實現內部判斷事件型別來處理，也沒有提供按順序觸發監聽器的語義，所以Spring提供了另一個介面，SmartApplicationListener：

Java程式碼  收藏程式碼
  1. public interface SmartApplicationListener extends ApplicationListener<ApplicationEvent>, Ordered {  
  2.         //如果實現支援該事件型別 那麼返回true  
  3.     boolean supportsEventType(Class<? extends ApplicationEvent> eventType);  
  4.         //如果實現支援“目標”型別，那麼返回true  
  5.     boolean supportsSourceType(Class<?> sourceType);  
  6.         //順序，即監聽器執行的順序，值越小優先順序越高  
  7.         int getOrder();  
  8. }  

該介面可方便實現去判斷支援的事件型別、目標型別，及執行順序。 

Spring事件機制的簡單例子

本例子模擬一個給多個人傳送內容（類似於報紙新聞）的例子。

1、定義事件

Java程式碼  收藏程式碼
  1. package com.sishuok.hello;  
  2. import org.springframework.context.ApplicationEvent;  
  3. public class ContentEvent extends ApplicationEvent {  
  4.     public ContentEvent(final String content) {  
  5.         super(content);  
  6.     }  
  7. }  

非常簡單，如果使用者傳送內容，只需要通過構造器傳入內容，然後通過getSource即可獲取。

2、定義無序監聽器

之所以說無序，類似於AOP機制，順序是無法確定的。

Java程式碼  收藏程式碼
  1. package com.sishuok.hello;  
  2. import org.springframework.context.ApplicationEvent;  
  3. import org.springframework.context.ApplicationListener;  
  4. import org.springframework.stereotype.Component;  
  5. @Component  
  6. public class LisiListener implements ApplicationListener<ApplicationEvent> {  
  7.     @Override  
  8.     public void onApplicationEvent(final ApplicationEvent event) {  
  9.         if(event instanceof ContentEvent) {  
  10.             System.out.println("李四收到了新的內容：" + event.getSource());  
  11.         }  
  12.     }  
  13. }  

1、使用@Compoent註冊Bean即可；

2、在實現中需要判斷event型別是ContentEvent才可以處理；

更簡單的辦法是通過泛型指定型別，如下所示

Java程式碼  收藏程式碼
  1. package com.sishuok.hello;  
  2. import org.springframework.context.ApplicationListener;  
  3. import org.springframework.stereotype.Component;  
  4. @Component  
  5. public class ZhangsanListener implements ApplicationListener<ContentEvent> {  
  6.     @Override  
  7.     public void onApplicationEvent(final ContentEvent event) {  
  8.         System.out.println("張三收到了新的內容：" + event.getSource());  
  9.     }  
  10. }  

3、定義有序監聽器 

實現SmartApplicationListener介面即可。

Java程式碼  收藏程式碼
  1. package com.sishuok.hello;  
  2. import org.springframework.context.ApplicationEvent;  
  3. import org.springframework.context.event.SmartApplicationListener;  
  4. import org.springframework.stereotype.Component;  
  5. @Component  
  6. public class WangwuListener implements SmartApplicationListener {  
  7.     @Override  
  8.     public boolean supportsEventType(final Class<? extends ApplicationEvent> eventType) {  
  9.         return eventType == ContentEvent.class;  
  10.     }  
  11.     @Override  
  12.     public boolean supportsSourceType(final Class<?> sourceType) {  
  13.         return sourceType == String.class;  
  14.     }  
  15.     @Override  
  16.     public void onApplicationEvent(final ApplicationEvent event) {  
  17.         System.out.println("王五在孫六之前收到新的內容：" + event.getSource());  
  18.     }  
  19.     @Override  
  20.     public int getOrder() {  
  21.         return 1;  
  22.     }  
  23. }  
Java程式碼  收藏程式碼
  1. package com.sishuok.hello;  
  2. import org.springframework.context.ApplicationEvent;  
  3. import org.springframework.context.event.SmartApplicationListener;  
  4. import org.springframework.stereotype.Component;  
  5. @Component  
  6. public class SunliuListener implements SmartApplicationListener {  
  7.     @Override  
  8.     public boolean supportsEventType(final Class<? extends ApplicationEvent> eventType) {  
  9.         return eventType == ContentEvent.class;  
  10.     }  
  11.     @Override  
  12.     public boolean supportsSourceType(final Class<?> sourceType) {  
  13.         return sourceType == String.class;  
  14.     }  
  15.     @Override  
  16.     public void onApplicationEvent(final ApplicationEvent event) {  
  17.         System.out.println("孫六在王五之後收到新的內容：" + event.getSource());  
  18.     }  
  19.     @Override  
  20.     public int getOrder() {  
  21.         return 2;  
  22.     }  
  23. }  
  1. supportsEventType：用於指定支援的事件型別，只有支援的才呼叫onApplicationEvent；
  2. supportsSourceType：支援的目標型別，只有支援的才呼叫onApplicationEvent；
  3. getOrder：即順序，越小優先順序越高

4、測試 

4.1、配置檔案

Java程式碼  收藏程式碼
  1. <context:component-scan base-package="com.sishuok"/>  

 就一句話，自動掃描註解Bean。

4.2、測試類

Java程式碼  收藏程式碼
  1. package com.sishuok;  
  2. import com.sishuok.hello.ContentEvent;  
  3. import org.junit.Test;  
  4. import org.junit.runner.RunWith;  
  5. import org.springframework.beans.factory.annotation.Autowired;  
  6. import org.springframework.context.ApplicationContext;  
  7. import org.springframework.test.context.ContextConfiguration;  
  8. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;  
  9. @RunWith(SpringJUnit4ClassRunner.class)  
  10. @ContextConfiguration(locations={"classpath:spring-config-hello.xml"})  
  11. public class HelloIT {  
  12.     @Autowired  
  13.     private ApplicationContext applicationContext;  
  14.     @Test  
  15.     public void testPublishEvent() {  
  16.         applicationContext.publishEvent(new ContentEvent("今年是龍年的部落格更新了"));  
  17.     }  
  18. }  

接著會輸出：

Java程式碼  收藏程式碼
  1. 王五在孫六之前收到新的內容：今年是龍年的部落格更新了  
  2. 孫六在王五之後收到新的內容：今年是龍年的部落格更新了  
  3. 李四收到了新的內容：今年是龍年的部落格更新了  
  4. 張三收到了新的內容：今年是龍年的部落格更新了  

一個簡單的測試例子就演示完畢，而且我們使用spring的事件機制去寫相關程式碼會非常簡單。

Spring事件機制實現之前提到的註冊流程

具體請下載原始碼參考com.sishuok.register包裡的程式碼。此處貼一下原始碼結構：


  

這裡講解一下Spring對非同步事件機制的支援，實現方式有兩種：

1、全域性非同步

即只要是觸發事件都是以非同步執行，具體配置（spring-config-register.xml）如下：

相關推薦

Spring事件驅動模型詳解

事件驅動模型簡介事件驅動模型也就是我們常說的觀察者，或者釋出-訂閱模型；理解它的幾個關鍵點：首先是一種物件間的一對多的關係；最簡單的如交通訊號燈，訊號燈是目標（一方），行人注視著訊號燈（多方）；當目標傳送改變（釋出），觀察者（訂閱者）就可以接收到改變；觀察者如何處理（如行人如何走，是快走/慢走/不走，目標不會

SpringBoot整合RabbitMQ之Spring事件驅動模型

實戰背景：在進入RabbitMQ各大技術知識點之前，我們先來談談跟事件驅動息息相關的ApplicationEvent、ApplicationListener以及ApplicationEventPublisher這三大元件，點選進去看其原始碼可以發現裡面使用的CachingConnectionFa

Nginx學習之路（九）Nginx中的事件驅動過程詳解-----connection事件的註冊過程

在上一篇文章Nginx學習之路（八）Nginx中的事件驅動過程詳解-----以listenfd註冊過程為例中舉了listenfd的註冊過程來說明事件驅動中的事件註冊過程，這是一個簡單的過程，今天來說明下當瀏覽器發起一個http請求時，nginx是如何將這個事件註冊到epoll

Nginx學習之路（八）Nginx中的事件驅動過程詳解-----以listenfd註冊過程為例

Nginx的高效得益於它的事件驅動機制，整個事件驅動機制基本框架就是linux下的select,poll,epoll這幾個IO多路複用模式，但是nginx絕不單單只是使用它們這麼簡單，今天以epoll模式為例，從nginx最開始的listenfd的監聽的過程來說明nginx是

Spring基於事件驅動模型的訂閱釋出模式程式碼例項詳解

事件驅動模型簡介 事件驅動模型也就是我們常說的觀察者，或者釋出-訂閱模型；理解它的幾個關鍵點： 首先是一種物件間的一對多的關係；最簡單的如交通訊號燈，訊號燈是目標（一方），行人注視著訊號燈（多方）；當目標傳送改變（釋出），觀察者（訂閱者）就可以接收到改變；觀察者如何處理

事件驅動模型例項詳解（Java篇）

這個按鈕的時候，按鈕物件會直接把這次點選感覺傳遞給ButtonEventHandler的actionPerformed方法處理，為養成較好的程式設計習慣，我們中心並不建議學員直接在該委託方法中編寫程式碼，而是需要將該事件處理再次轉發給窗體中的某個方法來處理，這個方法的命名也必須是有規則的，就是事件源名＋下劃線

（六）觀察者模式詳解（包含觀察者模式JDK的漏洞以及事件驅動模型）

import java.util.Vector; //被觀察者類 public class Observable { //這是一個改變標識，來標記該被觀察者有沒有改變 private boolean changed = false; //持有一個觀察者列表 private

js 事件模型詳解

捕獲 dom0 dde html true 一個 lse 之前 {} 　　把js的事件模型，分為兩類，DOM0級和DOM2級， 　　DOM0級 通常直接在DOM對象上綁定函數對象，指定事件類型，dom.onClick = function(){};類似於這種寫法，移除事件，

redis的事件模型詳解（結合Reactor設計模式）

        文章基於redis-4.0.1原始碼詳細介紹一下redis的事件模型。      一、redis事件模型概覽        redis是一個事件驅動的服務程式，在redis的服務程式中存在兩種型別的事件，分別是檔案事件和時間事件。檔案事件是對網路通訊操作的統稱

spring event的事件驅動模型的最佳實踐@EventListene

我們知道觀察者模式可以實現程式碼的解耦，而spring的event模型就是這種設計模式的極佳體現。一個事件包含：事件釋出、監聽、和事件源。在spring中我們可以通過ApplicationContext的publishEvent方法去釋出事件；通過實現Appl

宋寶華《Linux裝置驅動開發詳解》——sysfs檔案系統與linux裝置模型（5.4.2）

以下讀書筆記內容，摘自宋寶華《Linux裝置驅動開發詳解》一書。 1、sysfs檔案系統的簡介 （1）linux2.6以後的核心引進syfs檔案系統，是虛擬檔案系統； （2）產生一個包括所有系統硬體

Linux下五種I/O模型詳解（阻塞IO、非阻塞IO、IO複用、訊號驅動、非同步IO）

文章轉載自微信公眾號：漫話程式設計 1 什麼是I/O 程式是由資料+指令構成的，執行程式的過程可以分成下面這幾步： 1.將程式碼載入到記憶體中，逐條執行記憶體中的程式碼 2.在執行程式碼的過程中，可能需要對檔案的讀寫，即將檔案輸入（Input）

Spring原始碼之事件驅動模型

SpringContext中初始化事件釋出者 ### //spring初始化事件的地方 //spring初始化事件的地方 public abstract class AbstractApplicationContext extends DefaultResou

elasticSearch+spring 整合 maven依賴詳解

elastics tail -s clas 1.0 too group nbsp snapshot 摘自：http://www.mayou18.com/detail/nTxPQSyu.html 【Elasticsearch基礎】elasticSearch+spring 整合

綜合運用: C++11 多線程下生產者消費者模型詳解（轉）

並發 rep 生產 我會 交流 模型 操作 const ref 生產者消費者問題是多線程並發中一個非常經典的問題，相信學過操作系統課程的同學都清楚這個問題的根源。本文將就四種情況分析並介紹生產者和消費者問題，它們分別是：單生產者-單消費者模型，單生產者-多消費者模型，多生產

spring配置文件詳解

type ransac 啟動 toc ref 意圖 new admins 裝配 轉自： http://book.51cto.com/art/201004/193743.htm 此處詳細的為我們講解了spring2.5的實現原理，感覺非常有用

Guava ---- EventBus事件驅動模型

sim div spa tar 共享 execution ext 實例 處理 在軟件開發過程中， 難免有信息的共享或者對象間的協作。 怎樣讓對象間信息共享高效， 而且耦合性低。 這是一個難題。 而耦合性高將帶來編碼改動牽一發而動全身的連鎖效應。 Spring的風靡正

Java虛擬機：內存模型詳解

調用 數據類型 可擴展 空間 共享 sof 虛擬機 進程 部分 版權聲明：本文為博主原創文章，轉載請註明出處，歡迎交流學習！ 我們都知道，當虛擬機執行Java代碼的時候，首先要把字節碼文件加載到內存，那麽這些類的信息都存放在內存中的哪個區域呢？當我們創建一個

事件驅動模型

image 獨立 之間 如果 png 實例 相等 不知道 響應時間 一、為什麽要用事件驅動模型？ 在UI編程中，常常要對鼠標點擊進行相應，首先如何獲得鼠標點擊呢？方式一：創建一個線程，該線程一直循環檢測是否有鼠標點擊。 那麽這個方式有以下幾個缺點：1. CPU資源浪費，可能

筆記：Spring Cloud Ribbon RestTemplate 詳解

定義 方法 template 包含 mediatype pst ron request temp 詳細介紹RestTemplate 針對幾種不同請求類型和參數類型的服務調用實現，示例代碼中的 restTemplate 都是通過Spring 註