2. 程式人生 > >Spring事件機制

Spring事件機制

阿新 • • 發佈：2019-01-26
Java提供了事件機制，在使用spring的時候，我們可以把普通的java事件操作定義為bean整合到bean容器中，但還有一種更方便的方式，即使用spring已整合的事件支援。
在使用Spring的事件支援時，我們需要關注以下幾個物件：
      1. ApplicationEvent：繼承自EventObject，同時是spring的application中事件的父類，需要被自定義的事件繼承。
      2. ApplicationListener：繼承自EventListener，spring的application中的監聽器必須實現的介面，需要被自定義的監聽器實現其onApplicationEvent方法
      3. ApplicationEventPublisherAware：在spring的context中希望能釋出事件的類必須實現的介面，該介面中定義了設定ApplicationEventPublisher的方法，由ApplicationContext呼叫並設定。在自己實現的ApplicationEventPublisherAware子類中，需要有ApplicationEventPublisher屬性的定義。
      4. ApplicationEventPublisher：spring的事件釋出者介面，定義了釋出事件的介面方法publishEvent。因為ApplicationContext實現了該介面，因此spring的ApplicationContext例項具有釋出事件的功能(publishEvent方法在AbstractApplicationContext中有實現)。在使用的時候，只需要把ApplicationEventPublisher的引用定義到ApplicationEventPublisherAware的實現中，spring容器會完成對ApplicationEventPublisher的注入。

在spring的bean配置中，因為事件是由事件源發出的，不需要註冊為bean由spring容器管理。所以在spring的配置中，只需配置自定義的ApplicationEventListener和publisherAware(即實現了ApplicationEventPublisherAware介面的釋出類)，而對於ApplicationEventPublisher的管理和注入都由容器來完成。

基於spring的事件簡單實現如下：
1. 定義ApplicationEvent
Java程式碼
複製程式碼 收藏程式碼
  1. package com.nuc.event;   
  2. import org.springframework.context.ApplicationEvent;   
  3. /**  
  4.  * 定義Spring容器中的事件，與java普通的事件定義相比，只是繼承的父類不同而已，在  
  5.  * 在定義上並未有太大的區別，畢竟ApplicationEvent也是繼承自EventObject的。  
  6.  */  
  7. public class MethodExecutionEvent extends ApplicationEvent {   
  8.     private static final long serialVersionUID = 2565706247851725694L;   
  9.     private String methodName;   
  10.     private MethodExecutionStatus methodExecutionStatus;   
  11.     public MethodExecutionEvent(Object source) {   
  12.         super(source);   
  13.     }   
  14.     public MethodExecutionEvent(Object source, String methodName, MethodExecutionStatus methodExecutionStatus) {   
  15.         super
    (source);   
  16.         this.methodName = methodName;   
  17.         this.methodExecutionStatus = methodExecutionStatus;   
  18.     }   
  19.     public String getMethodName() {   
  20.         return methodName;   
  21.     }   
  22.     public void setMethodName(String methodName) {   
  23.         this.methodName = methodName;   
  24.     }   
  25.     public MethodExecutionStatus getMethodExecutionStatus() {   
  26.         return methodExecutionStatus;   
  27.     }   
  28.     public void setMethodExecutionStatus(MethodExecutionStatus methodExecutionStatus) {   
  29.         this.methodExecutionStatus = methodExecutionStatus;   
  30.     }   
  31. }  
package com.nuc.event;

import org.springframework.context.ApplicationEvent;
/**
 * 定義Spring容器中的事件，與java普通的事件定義相比，只是繼承的父類不同而已，在
 * 在定義上並未有太大的區別，畢竟ApplicationEvent也是繼承自EventObject的。
 */
public class MethodExecutionEvent extends ApplicationEvent {

    private static final long serialVersionUID = 2565706247851725694L;
    private String methodName;
    private MethodExecutionStatus methodExecutionStatus;
    
    public MethodExecutionEvent(Object source) {
        super(source);
    }
    
    public MethodExecutionEvent(Object source, String methodName, MethodExecutionStatus methodExecutionStatus) {
        super(source);
        this.methodName = methodName;
        this.methodExecutionStatus = methodExecutionStatus;
    }

    public String getMethodName() {
        return methodName;
    }

    public void setMethodName(String methodName) {
        this.methodName = methodName;
    }

    public MethodExecutionStatus getMethodExecutionStatus() {
        return methodExecutionStatus;
    }

    public void setMethodExecutionStatus(MethodExecutionStatus methodExecutionStatus) {
        this.methodExecutionStatus = methodExecutionStatus;
    }
}

2. 定義ApplicationEventListener
Java程式碼 複製程式碼 收藏程式碼
  1. package com.nuc.listener;   
  2. import org.springframework.context.ApplicationEvent;   
  3. import org.springframework.context.ApplicationListener;   
  4. import com.nuc.event.MethodExecutionEvent;   
  5. import com.nuc.event.MethodExecutionStatus;   
  6. /**  
  7.  * Spring容器中的事件監聽器，與java中基本的事件監聽器的定義相比，這裡需要實現ApplicationListener介面  
  8.  * ApplicationListener介面雖然繼承自EventListener，但擴充套件了EventListener  
  9.  * 它在介面宣告中定義了onApplicationEvent的介面方法，而不像EventListener只作為標記性介面。  
  10.  */  
  11. public class MethodExecutionEventListener implements ApplicationListener {   
  12.     public void onApplicationEvent(ApplicationEvent event) {   
  13.         if (event instanceof MethodExecutionEvent) {   
  14.            if (MethodExecutionStatus.BEGIN   
  15.                     .equals(((MethodExecutionEvent) event)   
  16.                             .getMethodExecutionStatus())) {   
  17.                 System.out.println("It's beginning");   
  18.             }   
  19.             if (MethodExecutionStatus.END.equals(((MethodExecutionEvent) event).getMethodExecutionStatus())) {   
  20.                 System.out.println("It's ending");   
  21.             }   
  22.         }   
  23.     }   
  24. }  
package com.nuc.listener;

import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;

import com.nuc.event.MethodExecutionEvent;
import com.nuc.event.MethodExecutionStatus;
/**
 * Spring容器中的事件監聽器，與java中基本的事件監聽器的定義相比，這裡需要實現ApplicationListener介面
 * ApplicationListener介面雖然繼承自EventListener，但擴充套件了EventListener
 * 它在介面宣告中定義了onApplicationEvent的介面方法，而不像EventListener只作為標記性介面。
 */

public class MethodExecutionEventListener implements ApplicationListener {

    public void onApplicationEvent(ApplicationEvent event) {
        if (event instanceof MethodExecutionEvent) {
           if (MethodExecutionStatus.BEGIN
                    .equals(((MethodExecutionEvent) event)
                            .getMethodExecutionStatus())) {
                System.out.println("It's beginning");
            }
            if (MethodExecutionStatus.END.equals(((MethodExecutionEvent) event).getMethodExecutionStatus())) {
                System.out.println("It's ending");
            }
        }
    }
}

3. 定義ApplicationEventPublisherAware
Java程式碼 複製程式碼 收藏程式碼
  1. package com.nuc.publisher;   
  2. import org.springframework.context.ApplicationEventPublisher;   
  3. import org.springframework.context.ApplicationEventPublisherAware;   
  4. import com.nuc.event.MethodExecutionEvent;   
  5. import com.nuc.event.MethodExecutionStatus;   
  6. public class MethodExecutionEventPublisher implements  
  7.         ApplicationEventPublisherAware {   
  8.     private ApplicationEventPublisher eventPublisher;   
  9.     public void methodToMonitor() {   
  10.         MethodExecutionEvent beginEvent = new MethodExecutionEvent(this, "methodToMonitor", MethodExecutionStatus.BEGIN);   
  11.         this.eventPublisher.publishEvent(beginEvent);   
  12.         //TODO   
  13.         MethodExecutionEvent endEvent = new MethodExecutionEvent(this, "methodToMonitor", MethodExecutionStatus.END);   
  14.         this.eventPublisher.publishEvent(endEvent);   
  15.     }   
  16.     public void setApplicationEventPublisher(   
  17.             ApplicationEventPublisher applicationEventPublisher) {   
  18.         this.eventPublisher = applicationEventPublisher;   
  19.     }   
  20. }  
package com.nuc.publisher;

import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationEventPublisherAware;

import com.nuc.event.MethodExecutionEvent;
import com.nuc.event.MethodExecutionStatus;

public class MethodExecutionEventPublisher implements
        ApplicationEventPublisherAware {

    private ApplicationEventPublisher eventPublisher;
    
    public void methodToMonitor() {
        MethodExecutionEvent beginEvent = new MethodExecutionEvent(this, "methodToMonitor", MethodExecutionStatus.BEGIN);
        this.eventPublisher.publishEvent(beginEvent);
        //TODO
        MethodExecutionEvent endEvent = new MethodExecutionEvent(this, "methodToMonitor", MethodExecutionStatus.END);
        this.eventPublisher.publishEvent(endEvent);
    }
    
    public void setApplicationEventPublisher(
            ApplicationEventPublisher applicationEventPublisher) {
        this.eventPublisher = applicationEventPublisher;
    }
}

4. 定義bean配置
Java程式碼 複製程式碼 收藏程式碼
  1. <?xml version="1.0" encoding="GBK"?>   
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd"  
  5.     default-autowire="byName">   
  6.     <bean id="methodExecListener" class="com.nuc.listener.MethodExecutionEventListener"></bean>   
  7.     <bean id="evtPublisher" class="com.nuc.publisher.MethodExecutionEventPublisher"></bean>    
  8. </beans>  
<?xml version="1.0" encoding="GBK"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd"
	default-autowire="byName">
	<bean id="methodExecListener" class="com.nuc.listener.MethodExecutionEventListener"></bean>
	<bean id="evtPublisher" class="com.nuc.publisher.MethodExecutionEventPublisher"></bean>	
</beans>

5. 使用事件
Java程式碼 複製程式碼 收藏程式碼
  1. package com.nuc;   
  2. import org.springframework.context.ApplicationContext;   
  3. import org.springframework.context.support.ClassPathXmlApplicationContext;   
  4. import com.nuc.publisher.MethodExecutionEventPublisher;   
  5. public class App    
  6. {   
  7.     public static void main( String[] args )   
  8.     {   
  9.         ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");   
  10.         MethodExecutionEventPublisher publisher = (MethodExecutionEventPublisher)context.getBean("evtPublisher");   
  11.         publisher.methodToMonitor();   
  12.     }   
  13. }  
package com.nuc;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.nuc.publisher.MethodExecutionEventPublisher;

public class App 
{
    public static void main( String[] args )
    {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        MethodExecutionEventPublisher publisher = (MethodExecutionEventPublisher)context.getBean("evtPublisher");
        publisher.methodToMonitor();
    }
}


從實現來上，和使用基本的java事件流程大體一致，不同的是這裡不需要自定義釋出者，而使用spring實現提供的事件釋出實現。當然，這裡卻引入了ApplicationEventPublisherAware。  

相關推薦

java spring事件機制，釋出訂閱，簡單使用案例

spring配置檔案新增 <!-- 計劃任務配置，用 @Service @Lazy(false)標註類，用@Scheduled(cron = "0 0 2 * * ?")標註方法 --> <task:executor id="executor" pool-siz

觀察者模式實際應用場景-----Spring事件機制

以下虛擬碼是一個儲存訂單的功能，並會發送簡訊訊息： /** * Author heling on 2019/1/9 */ @Service public class OrderServiceImpl implements OrderService { @Override pub

spring事件機制-onApplicationEvent執行兩次

一、case復現事件定義Java程式碼  public class MyEvent extends ApplicationEvent {      public MyEvent(Object object) {          super(object);      }  

Spring事件機制

Java提供了事件機制，在使用spring的時候，我們可以把普通的java事件操作定義為bean整合到bean容器中，但還有一種更方便的方式，即使用spring已整合的事件支援。 在使用Spring的事件支援時，我們需要關注以下幾個物件：       1. Applic

15、Spring事件機制_觀察者模式

 private static final long serialVersionUID = 1L;  private String id;  private String name;  public MyTestEvent(Object source) {   super(source);  }  publi

如何自定義事件(Spring事件機制淺談)

       LZ第一次在工作中接觸Spring事件機制是專案中的定時任務,當Spring容器初始化完成時,把配置在資料庫中的定時任務資料全部載入.此時只用定義一個類實現ApplicationListener<ContextRefreshedEvent>介面,並

spring事件機制——非同步配置

這裡講解一下Spring對非同步事件機制的支援，實現方式有兩種：1、全域性非同步即只要是觸發事件都是以非同步執行，具體配置（spring-config-register.xml）如下： <task:executor id="executor" pool-size="10

spring事件監聽機制

ide could 事情 task object 負責 his try and 事件機制的主要成員：　　 事件 事件監聽器（監聽事件觸發，處理一些事情） 事件源（發布事件） javaSE 提供了一系列自定義事件的標準。 EvenObject,為javaSE提供

Spring---ApplicationContext的事件機制

ApplicationContext的事件機制簡介 1，事件源：ApplicationContext.publishEvent()方法：用於主動觸發容器事件。 2，事件：ApplicationEvent類,容器事件，必須由ApplicationContext釋出。（實際

Spring的事件機制詳解

同步事件和非同步事件 　　同步事件:在一個執行緒裡,按順序執行業務,做完一件事再去做下一件事.       非同步事件:在一個執行緒裡,做一個事的同事,可以另起一個新的執行緒執行另一件事,這樣兩件事可以同時執行. 　　用一個例子來解釋同步事件和非同步事件的使用場景,有時

Tomcat與Spring中的事件機制詳解

Tomcat與Spring中的事件機制詳解 引言 最近在看tomcat原始碼，原始碼中出現了大量事件訊息，可以說整個tomcat的啟動流程都可以通過事件派發機制串起來，研究透了tomcat的各種事件訊息，基本上對tomcat的啟動流程也就有了一個整體的認識。在這一基礎上，聯想到之前在看spr

Spring的事件機制

當把一個事件釋出到Spring提供的ApplicationContext中，被監聽器偵測到，就會執行對應的處理方法。 事件本身 事件是一個自定義的類，需要繼承Spring提供的ApplicationEvent。 @Data public class

[SpringBoot] Spring的事件機制

直接上程式碼： 一.定義事件 public class MyEvent extends ApplicationEvent { private String msg; public MyEvent(Object source, String msg) {

Spring進階之路(2)-ApplicationContext容器以及事件機制

Spring容器最基本的介面是BeanFactory,他負責配置、建立、管理bean，他的子介面之一：ApplicationContext,也叫做spring的上下文。ApplicationConte

Spring中ApplicationContext的事件機制

ApplicationContext事件機制是觀察者設計模式的 實現，通過ApplicationEvent類和ApplicationListener介面，可以實現ApplicationContext事件

spring中事件機制

一、一些概念 　事件是可以被控制元件識別的操作，如按下確定按鈕，選擇某個單選按鈕或者複選框。每一種控制元件有自己可以識別的事件，如窗體的載入、單擊、雙擊等事件，編輯框(文字框)的文字改變事，等等。事件有系統事件和使用者事件。系統事件由系統激發，如時間每隔24小時，銀行儲戶的存

Spring中的事件機制之觀察者模式

為什麼要使用java中的事件機制 應用場景型別： 1. 使用者註冊成功後，此時需要做以下這麼多事情： 1. 加積分 2. 發確認郵件 3. 如果時遊戲帳戶，此時贈送遊戲大禮包 耦合性高的解決辦法： 1. 建立一個UserService

Spring Boot的訊息事件機制

Spring Boot自帶了訊息機制，可以讓我們在一個地方釋出訊息，多個地方同時接收訊息並處理訊息，當然這是在同一個JVM記憶體下

從spring原始碼汲取營養：模仿spring事件釋出機制，解耦業務程式碼

前言 最近在專案中做了一項優化，對業務程式碼進行解耦。我們部門做的是警用系統，通俗的說，可理解為110報警。一條警情，會先後經過接警員、處警排程員、一線警員，警情是需要記錄每一步的日誌，是要可追溯的，比如報警人張小三在2019-12-02 00:02:01時間報警，接警員A在1分鐘後，將該警情記錄完成，並分派

Spring 事件監聽機制及原理分析

## 簡介 在JAVA體系中，有支援實現事件監聽機制，在Spring 中也專門提供了一套事件機制的介面，方便我們實現。比如我們可以實現當用戶註冊後，給他傳送一封郵件告訴他註冊成功的一些資訊，比如使用者訂閱的主題更新了，通知使用者注意及時檢視等。 ## 觀察者模式 觀察者模式還有很多其他的稱謂，如釋出-訂