spring-event-事件監聽機制實現

primaryC發表於2024-03-08

Spring事件

1. 事件監聽機制概述

1. 場景

模型版本更新了，新版本需要繼承老版本的構件分享、自定義屬性、著色資料，以後還可能有其他資料要繼承，這些資料之間沒有直接聯絡，就是當模型版本變更的時候，他們各自需要執行。

2. 涉及的三個物件

事件源（提供事件處理時的後設資料）

這裡就是模型版本更新了

監聽器（事件處理者）

構件分享繼承是一個監聽者，監聽到版本更新的事件，需要自己處理點東西
自定義屬性繼承也是一個監聽者。。
著色資料繼承也是一個監聽者。。。

事件釋出者（呼叫者）

2. 示例

1. 事件源 ApplicationEvent

定義一個事件源，只需要繼承 org.springframework.context.ApplicationEvent.ApplicationEvent 或其子類

package com.demo.event;

import org.springframework.context.ApplicationEvent;

/**
 * 事件源：模型變更了
 * 虛擬碼：模型變更
 * */
public class ModelExchangeEvent extends ApplicationEvent {

    private Integer modelId;
    private Integer modelVersion;

    /**
     * Create a new {@code ApplicationEvent}.
     *
     * @param source the object on which the event initially occurred or with
     *               which the event is associated (never {@code null})
     */
    public ModelExchangeEvent(Object source, Integer modelId, Integer modelVersion) {
        super(source);
        this.modelId = modelId;
        this.modelVersion = modelVersion;
    }

    public Integer getModelId() {
        return modelId;
    }
    public Integer getModelVersion() {
        return modelVersion;
    }
    public void setModelId(Integer modelId) {
        this.modelId = modelId;
    }
    public void setModelVersion(Integer modelVersion) {
        this.modelVersion = modelVersion;
    }
}

2. 監聽者 ApplicationListener

監聽器可以有多個，每個監聽器代表一種操作。

透過繼承 ApplicationListener 實現監聽器

package com.demo.event;

import lombok.extern.slf4j.Slf4j;
import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

/**
 * 虛擬碼：著色繼承
 * 實現 `ApplicationListener` 方式
 * */
@Component
@Slf4j
public class ModelExchangeColorListener implements ApplicationListener<ModelExchangeEvent> {
    @Override
    public void onApplicationEvent(ModelExchangeEvent e) {
        log.info("收到模型{}版本{}的變更通知！著色繼承開始！", e.getModelId(), e.getModelVersion());
        //模擬邏輯執行
        try {
            Thread.sleep(2_000);
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
        log.info("著色繼承結束！");
    }
}

透過 @EventListener 註解實現監聽器

package com.demo.event;

import lombok.extern.slf4j.Slf4j;
import org.springframework.context.event.EventListener;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

/**
 * 虛擬碼：繼承
 * 使用 @EventListener 方式
 * */
@Component
@Slf4j
public class ModelExchangePropertiesListener {

    /**
     * 屬性繼承
     * */
    @EventListener(ModelExchangeEvent.class)
    public void onEvent(ModelExchangeEvent e){
        log.info("收到模型{}版本{}的變更通知！自定義屬性繼承開始！", e.getModelId(), e.getModelVersion());
        //模擬邏輯執行
        try {
            Thread.sleep(2_000);
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
        log.info("自定義屬性繼承結束！");
    }

    /**
     * 分享繼承
     * */
    @EventListener(ModelExchangeEvent.class)
    public void sss(ModelExchangeEvent e){
        log.info("收到模型{}版本{}的變更通知！分享繼承開始！", e.getModelId(), e.getModelVersion());
        //模擬邏輯執行
        try {
            Thread.sleep(2_000);
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
        log.info("分享繼承結束！");
    }
}

3. 事件釋出者 `ApplicationEventPublisher`

實現了 ApplicationEventPublisher 介面，就是一個釋出者，透過 publishEvent 方法釋出事件。

直接注入 ApplicationEventPublisher 物件

package com.demo.controller;

import com.demo.event.ModelExchangeEvent;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationEventPublisherAware;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/model")
@Slf4j
public class ModelController{

    /**
     * 使用 ApplicationEventPublisher 釋出事件
     * */
    @Autowired
    private ApplicationEventPublisher ap;

    @RequestMapping("/exchange")
    public void exchange(){
        log.info("虛擬碼：模型變更的邏輯");
        ap.publishEvent(new ModelExchangeEvent(ap, 9001, 2));
    }
}

這裡透過自動注入一個 ApplicationEventPublisher 來發布事件，這個注入的 publisher 其實就是啟動的 Spring 容器物件 ConfigurableApplicationContext run = SpringApplication.run(EventMain.class, args)，也就是這個 run。

透過 ApplicationEventPublisherAware 來手動設定 publisher

package com.demo.controller;

import com.demo.event.ModelExchangeEvent;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationEventPublisherAware;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/model")
@Slf4j
public class ModelController implements ApplicationEventPublisherAware{

    /**
     * 使用 ApplicationEventPublisher 釋出事件
     * */
    private ApplicationEventPublisher ap;

    @RequestMapping("/exchange")
    public void exchange(){
        log.info("虛擬碼：模型變更的邏輯");
        this.ap.publishEvent(new ModelExchangeEvent(ap, 9001, 2));
    }

    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
        this.ap = applicationEventPublisher;
    }
}

跟上面差距不大

3. 重要元件說明

1. ApplicationEvent

Spring中所有事件的基類，繼承自java.util.EventObject。開發人員可以透過繼承ApplicationEvent類來建立自定義事件，在事件物件中封裝相關資訊。事件可以同步或非同步觸發，並支援條件事件和層次事件等特性。

2. ApplicationListener

是一個監聽器介面，用於處理特定型別的事件。當被感興趣的事件發生時，容器會呼叫相應的監聽器方法，傳入該事件作為引數。開發人員可以實現ApplicationListener介面來建立自己的監聽器，然後使用@EventListener註解或者配置檔案的方式進行註冊。

3. ApplicationEventMulticaster

是一個事件廣播器，將事件傳送給所有已註冊的ApplicationListener。預設情況下，Spring使用SimpleApplicationEventMulticaster實現事件廣播，但也可以透過配置使用其他實現方式，例如AsyncApplicationEventMulticaster和SimpleThreadScopeEventMulticaster。
就是透過這玩意來呼叫每個 listener 的處理邏輯。

4. ApplicationEventPublisher

釋出者，透過這個元件來發布事件。

4. 多個監聽者執行順序

預設情況下多個監聽者同步執行，使用 @Order 註解標註執行順序。

5. 非同步呼叫

也有兩種方式。

1. ApplicationEventMulticaster

package com.demo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.event.ApplicationEventMulticaster;
import org.springframework.context.event.SimpleApplicationEventMulticaster;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolExecutorFactoryBean;
import org.springframework.stereotype.Component;

import java.util.concurrent.Executor;

/**
 * 配置監聽器非同步執行
 * */
@Configuration
public class ListenerConfig {

    @Bean
    public ApplicationEventMulticaster applicationEventMulticaster() { //@1
        //建立一個事件廣播器
        SimpleApplicationEventMulticaster result = new SimpleApplicationEventMulticaster();
        //給廣播器提供一個執行緒池，透過這個執行緒池來呼叫事件監聽器
        Executor executor = this.applicationEventMulticasterThreadPool().getObject();
        //設定非同步執行器
        result.setTaskExecutor(executor);//@1
        return result;
    }

    //提供一個執行緒池
    @Bean
    public ThreadPoolExecutorFactoryBean applicationEventMulticasterThreadPool() {
        ThreadPoolExecutorFactoryBean result = new ThreadPoolExecutorFactoryBean();
        result.setThreadNamePrefix("modelThread-");
        result.setCorePoolSize(2);
        return result;
    }
}

原理

自定義 ApplicationEventMulticaster，並設定其執行緒池，監聽器最終是透過ApplicationEventMulticaster內部的實現來呼叫的，所以我們關注的重點就是這個類，這個類預設有個實現類 SimpleApplicationEventMulticaster，這個類是支援監聽器非同步呼叫的,內部有個執行緒池欄位:

private Executor taskExecutor;

SimpleApplicationEventMulticaster 執行邏輯：

@Override
public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
    ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
    Executor executor = getTaskExecutor();
    for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {
        if (executor != null) { 
            //執行緒池物件不為 null，就提交自定義監聽事件到執行緒池中
            executor.execute(() -> invokeListener(listener, event));
        }
        else {
            //執行緒池物件為 null，就順序執行每個 listener 自定義監聽事件
            invokeListener(listener, event);
        }
    }
}

所以我們需要定義一個 SimpleApplicationEventMulticaster 的 bean 並設定其執行緒池.

弊端：這樣會使所有的監聽器都非同步執行

2. @Async

@EnableAsync 標註在啟動類上，來標識支援非同步。@Async 標註在指定 listener 上。這種應該就是傳說中 bean 的非同步執行。

package com.demo.event;

import lombok.extern.slf4j.Slf4j;
import org.springframework.context.ApplicationListener;
import org.springframework.core.annotation.Order;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

/**
 * 虛擬碼：著色繼承
 * 實現 ApplicationListener 方式
 * */
@Component
@Slf4j
@Async
public class ModelExchangeColorListener implements ApplicationListener<ModelExchangeEvent> {
    @Override
    public void onApplicationEvent(ModelExchangeEvent e) {
        log.info("收到模型{}版本{}的變更通知！著色繼承開始！", e.getModelId(), e.getModelVersion());
        //模擬邏輯執行
        try {
            Thread.sleep(2_000);
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
        log.info("著色繼承結束！");
    }
}

package com.demo.event;

import lombok.extern.slf4j.Slf4j;
import org.springframework.context.event.EventListener;
import org.springframework.core.annotation.Order;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

/**
 * 虛擬碼：繼承
 * 使用 @EventListener 方式
 * */
@Component
@Slf4j
public class ModelExchangePropertiesListener {

    /**
     * 屬性繼承
     * */
    @EventListener(ModelExchangeEvent.class)
    @Async
    public void onEvent(ModelExchangeEvent e){
        log.info("收到模型{}版本{}的變更通知！自定義屬性繼承開始！", e.getModelId(), e.getModelVersion());
        //模擬邏輯執行
        try {
            Thread.sleep(2_000);
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
        log.info("自定義屬性繼承結束！");
    }

    /**
     * 分享繼承
     * */
    @EventListener(ModelExchangeEvent.class)
    @Async
    public void sss(ModelExchangeEvent e){
        log.info("收到模型{}版本{}的變更通知！分享繼承開始！", e.getModelId(), e.getModelVersion());
        //模擬邏輯執行
        try {
            Thread.sleep(2_000);
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
        log.info("分享繼承結束！");
    }
}

package com.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync;

@SpringBootApplication
@EnableAsync
public class EventMain {
    public static void main(String[] args) {
        SpringApplication.run(EventMain.class, args);
    }
}

預設的執行緒池 SimpleAsyncTaskExecutor 不太行，可以透過 @Async("applicationEventMulticasterThreadPool") 自己換一個。

package com.demo.event;

import lombok.extern.slf4j.Slf4j;
import org.springframework.context.ApplicationListener;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

/**
 * 虛擬碼：著色繼承
 * 實現 ApplicationListener 方式
 * */
@Component
@Slf4j
@Async("applicationEventMulticasterThreadPool")
public class ModelExchangeColorListener implements ApplicationListener<ModelExchangeEvent> {
    @Override
    public void onApplicationEvent(ModelExchangeEvent e) {
        log.info("收到模型{}版本{}的變更通知！著色繼承開始！", e.getModelId(), e.getModelVersion());
        //模擬邏輯執行
        try {
            Thread.sleep(2_000);
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
        log.info("著色繼承結束！");
    }
}

自定義的執行緒池

package com.demo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.event.ApplicationEventMulticaster;
import org.springframework.context.event.SimpleApplicationEventMulticaster;
import org.springframework.scheduling.concurrent.ThreadPoolExecutorFactoryBean;

import java.util.concurrent.Executor;

/**
 * 配置監聽器非同步執行
 * */
@Configuration
public class ListenerConfig {
    //提供一個執行緒池
    @Bean
    public ThreadPoolExecutorFactoryBean applicationEventMulticasterThreadPool() {
        ThreadPoolExecutorFactoryBean result = new ThreadPoolExecutorFactoryBean();
        result.setThreadNamePrefix("modelThread-");
        result.setCorePoolSize(2);
        return result;
    }
}

參考文獻

https://blog.csdn.net/lin1214000999/article/details/124707979
原理參考：https://cloud.tencent.com/developer/article/2364790

Apache ZooKeeper - 事件監聽機制初探
2020-11-17
Apache事件
Spring事件監聽機制原始碼解析
2022-03-27
Spring事件原始碼
Spring事件釋出與監聽機制
2021-06-27
Spring事件
Spring 事件監聽機制及原理分析
2020-11-25
Spring事件
Spring筆記(7) - Spring的事件和監聽機制
2020-11-12
Spring筆記事件
Halo 開源專案學習（六）：事件監聽機制
2022-04-28
事件
【Redis系列】Spring boot實現監聽Redis key失效事件
2021-01-25
RedisSpring Boot事件
事件和事件監聽器
2019-09-16
事件
監聽滑鼠事件
2018-07-11
事件
jQuery事件監聽
2018-09-26
jQuery事件
Flutter事件監聽
2020-05-30
Flutter事件
springboot事件監聽
2024-08-25
Spring Boot事件
js 監聽事件
2024-08-01
JS事件
JavaScript 事件監聽
2024-11-03
JavaScript事件
SpringBoot事件監聽機制及觀察者模式/釋出訂閱模式
2020-12-21
Spring Boot事件模式
js監聽手機橫豎屏事件
2020-12-02
JS事件
python使用裝飾器實現的事件中心（監聽器）
2024-06-10
Python事件
javascript事件機制底層實現原理
2018-06-03
JavaScript事件
扒去Spring事件監聽機制的外衣，竟然是觀察者模式
2022-12-23
Spring事件模式
vue之監聽事件
2019-03-12
Vue事件
初識事件監聽
2022-03-04
事件
監聽鍵盤事件
2021-11-19
事件
Lumen 實現 SQL 監聽
2019-07-12
SQL
深入理解事件機制的實現
2019-05-17
事件
Spring Boot 事件和監聽
2018-05-10
Spring Boot事件
deleted事件監聽報錯
2020-09-23
delete事件
如何移除事件監聽器
2023-03-16
事件
angular 監聽 Windows 滾動事件實現頁面滾動載入
2018-11-14
AngularWindows事件
java鍵盤監聽之視窗監聽的實現
2020-10-08
Java
java springboot監聽事件和處理事件
2024-07-08
JavaSpring Boot事件
從原始碼級別深挖Zookeeper監聽機制
2020-12-03
原始碼
iOS開發·KVO用法，原理與底層實現: runtime模擬實現KVO監聽機制（Blcok及Delgate方式）
2018-05-07
iOS
h5 storage事件監聽
2019-01-04
H5事件
Spring事件釋出與監聽
2019-12-12
Spring事件
監聽所有模型的 saved 事件
2020-06-10
模型事件
如何監聽SAP CRM BOR事件
2020-09-03
事件
flutter 中監聽滑動事件
2019-06-26
Flutter事件
java 監聽 redis 過期事件
2021-08-19
JavaRedis事件