package com.example.demo.event;

import org.springframework.context.ApplicationEvent;

// 事件類(lèi)
public class HierarchicalEventPropagationEvent extends ApplicationEvent {

    private String message;

    public HierarchicalEventPropagationEvent(Object source, String message) {
        super(source);
        this.message = message;
    }

    public String getMessage() {
        return message;
    }
}

package com.example.demo.listener;

import com.example.demo.event.HierarchicalEventPropagationEvent;
import org.springframework.context.ApplicationListener;

// 監(jiān)聽(tīng)器類(lèi)
public class HierarchicalEventPropagationListener implements ApplicationListener<HierarchicalEventPropagationEvent> {

    private String listenerId;

    public HierarchicalEventPropagationListener(String listenerId) {
        this.listenerId = listenerId;
    }

    @Override
    public void onApplicationEvent(HierarchicalEventPropagationEvent event) {
        System.out.println(listenerId + " received event - " + event.getMessage());
    }

}

ackage com.example.demo;

import com.example.demo.event.HierarchicalEventPropagationEvent;
import com.example.demo.listener.HierarchicalEventPropagationListener;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class DemoApplication {

    public static void main(String[] args) {
        // 創(chuàng)建父容器,注冊(cè)監(jiān)聽(tīng)器
        AnnotationConfigApplicationContext parentCtx = new AnnotationConfigApplicationContext();
        parentCtx.addApplicationListener(new HierarchicalEventPropagationListener("Parent Listener"));
        parentCtx.refresh();

        // 創(chuàng)建子容器,注冊(cè)監(jiān)聽(tīng)器
        AnnotationConfigApplicationContext childCtx = new AnnotationConfigApplicationContext();
        childCtx.setParent(parentCtx);
        childCtx.addApplicationListener(new HierarchicalEventPropagationListener("Child Listener"));
        childCtx.refresh();

        // 發(fā)布事件
        HierarchicalEventPropagationEvent event1 = new HierarchicalEventPropagationEvent(parentCtx, "Event from parent");
        parentCtx.publishEvent(event1);

        HierarchicalEventPropagationEvent event2 = new HierarchicalEventPropagationEvent(childCtx, "Event from child");
        childCtx.publishEvent(event2);
    }
}

package com.example.demo.listener;

import org.springframework.context.ApplicationListener;
import org.springframework.context.PayloadApplicationEvent;

/**
 * 通用監(jiān)聽(tīng)器，能監(jiān)聽(tīng)到所有類(lèi)型的PayloadApplicationEvent
 */
public class CustomObjectApplicationListener implements ApplicationListener<PayloadApplicationEvent> {
    
    @Override
    public void onApplicationEvent(PayloadApplicationEvent event) {
        System.out.println("收到PayloadApplicationEvent，數(shù)據(jù)是：" + event.getPayload());
    }
}

package com.example.demo.listener;

import org.springframework.context.ApplicationListener;
import org.springframework.context.PayloadApplicationEvent;

/**
 * 特定數(shù)據(jù)類(lèi)型的監(jiān)聽(tīng)器。這個(gè)監(jiān)聽(tīng)器專(zhuān)門(mén)監(jiān)聽(tīng)String類(lèi)型的PayloadApplicationEvent
 */
public class CustomStringApplicationListener implements ApplicationListener<PayloadApplicationEvent<String>> {
    
    @Override
    public void onApplicationEvent(PayloadApplicationEvent<String> event) {
        System.out.println("收到了字符串?dāng)?shù)據(jù)：" + event.getPayload());
    }
}

package com.example.demo;

import com.example.demo.listener.CustomObjectApplicationListener;
import com.example.demo.listener.CustomStringApplicationListener;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import java.util.Date;

public class DemoApplication {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();

        // 注冊(cè)監(jiān)聽(tīng)器
        ctx.addApplicationListener(new CustomObjectApplicationListener());
        ctx.addApplicationListener(new CustomStringApplicationListener());
        ctx.refresh();

        // 發(fā)送事件
        ctx.publishEvent("Hello, World!");  // 發(fā)送一個(gè)字符串
        ctx.publishEvent(2023);              // 發(fā)送一個(gè)整數(shù)
        ctx.publishEvent(new Date());        // 發(fā)送一個(gè)日期對(duì)象
    }
}

package com.example.demo.event;

import org.springframework.context.ApplicationEvent;

public class ArticlePublishedEvent extends ApplicationEvent {
    private String title;
    private String author;
    private String publishedDate;

    public ArticlePublishedEvent(Object source, String title, String author, String publishedDate) {
        super(source);
        this.title = title;
        this.author = author;
        this.publishedDate = publishedDate;
    }

    public String getTitle() {
        return title;
    }

    public String getAuthor() {
        return author;
    }

    public String getPublishedDate() {
        return publishedDate;
    }
}

import org.springframework.context.ApplicationListener;

public class ArticlePublishedListener implements ApplicationListener<ArticlePublishedEvent> {

    @Override
    public void onApplicationEvent(ArticlePublishedEvent event) {
        System.out.println("A new article has been published!");
        System.out.println("Title: " + event.getTitle());
        System.out.println("Author: " + event.getAuthor());
        System.out.println("Published Date: " + event.getPublishedDate());

        // Notify subscribers about the new article
        notifySubscribers(event);

        // Update search engine index with new article details
        updateSearchIndex(event);

        // Update statistical data about articles
        updateStatistics(event);
    }

    private void notifySubscribers(ArticlePublishedEvent event) {
        // Logic to notify subscribers (dummy logic for demonstration)
        System.out.println("Notifying subscribers about the new article titled: " + event.getTitle());
    }

    private void updateSearchIndex(ArticlePublishedEvent event) {
        // Logic to update search engine index (dummy logic for demonstration)
        System.out.println("Updating search index with the new article titled: " + event.getTitle());
    }

    private void updateStatistics(ArticlePublishedEvent event) {
        // Logic to update statistical data (dummy logic for demonstration)
        System.out.println("Updating statistics with the new article titled: " + event.getTitle());
    }
}
-----------------------------------
?著作權(quán)歸作者所有：來(lái)自51CTO博客作者華為云開(kāi)發(fā)者聯(lián)盟的原創(chuàng)作品，請(qǐng)聯(lián)系作者獲取轉(zhuǎn)載授權(quán)，否則將追究法律責(zé)任
掌握Spring事件監(jiān)聽(tīng)器的內(nèi)部邏輯與實(shí)現(xiàn)
https://blog.51cto.com/u_15214399/8112689

package com.example.demo;

import com.example.demo.event.ArticlePublishedEvent;
import com.example.demo.listener.ArticlePublishedListener;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class DemoApplication {

    public static void main(String[] args) {
        // Initialize Spring ApplicationContext
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();

        // Register listener
        ctx.addApplicationListener(new ArticlePublishedListener());
        ctx.refresh();

        // Simulate publishing an article
        ctx.publishEvent(new ArticlePublishedEvent(ctx, "Spring Events", "John Doe", "2023-09-15"));
    }
}
-----------------------------------
?著作權(quán)歸作者所有：來(lái)自51CTO博客作者華為云開(kāi)發(fā)者聯(lián)盟的原創(chuàng)作品，請(qǐng)聯(lián)系作者獲取轉(zhuǎn)載授權(quán)，否則將追究法律責(zé)任
掌握Spring事件監(jiān)聽(tīng)器的內(nèi)部邏輯與實(shí)現(xiàn)
https://blog.51cto.com/u_15214399/8112689

public void publishEvent(ApplicationEvent event) {
    this.publishEvent(event, (ResolvableType)null);
}

public void publishEvent(Object event) {
    this.publishEvent(event, (ResolvableType)null);
}

protected void publishEvent(Object event, @Nullable ResolvableType eventType) {
    // 檢查事件對(duì)象是否為空，確保發(fā)布的事件是有意義的
    Assert.notNull(event, "Event must not be null");

    // 判斷傳入的事件是否已經(jīng)是ApplicationEvent類(lèi)型，如果是，則無(wú)需再進(jìn)行包裝
    Object applicationEvent;
    if (event instanceof ApplicationEvent) {
        applicationEvent = (ApplicationEvent)event;
    } else {
        // 如果傳入的事件不是ApplicationEvent類(lèi)型，則將其包裝為PayloadApplicationEvent
        applicationEvent = new PayloadApplicationEvent(this, event);
        // 如果未指定事件類(lèi)型，那么從包裝后的事件中獲取其真實(shí)類(lèi)型
        if (eventType == null) {
            eventType = ((PayloadApplicationEvent)applicationEvent).getResolvableType();
        }
    }

    // 判斷當(dāng)前是否存在earlyApplicationEvents列表
    if (this.earlyApplicationEvents != null) {
        // 如果存在，說(shuō)明ApplicationContext還未完全初始化，將事件添加到此列表中，稍后再進(jìn)行處理
        this.earlyApplicationEvents.add(applicationEvent);
    } else {
        // 如果ApplicationContext已經(jīng)初始化，那么直接通過(guò)事件多播器廣播事件
        this.getApplicationEventMulticaster().multicastEvent((ApplicationEvent)applicationEvent, eventType);
    }

    // 如果存在父ApplicationContext，則也將事件發(fā)布到父容器中
    if (this.parent != null) {
        if (this.parent instanceof AbstractApplicationContext) {
            // 如果父容器是AbstractApplicationContext類(lèi)型，則帶上事件類(lèi)型進(jìn)行發(fā)布
            ((AbstractApplicationContext)this.parent).publishEvent(event, eventType);
        } else {
            // 否則，只傳遞事件對(duì)象進(jìn)行發(fā)布
            this.parent.publishEvent(event);
        }
    }
}
-----------------------------------
?著作權(quán)歸作者所有：來(lái)自51CTO博客作者華為云開(kāi)發(fā)者聯(lián)盟的原創(chuàng)作品，請(qǐng)聯(lián)系作者獲取轉(zhuǎn)載授權(quán)，否則將追究法律責(zé)任
掌握Spring事件監(jiān)聽(tīng)器的內(nèi)部邏輯與實(shí)現(xiàn)
https://blog.51cto.com/u_15214399/8112689

public class SimpleApplicationEventMulticaster extends AbstractApplicationEventMulticaster {

    // 可選的任務(wù)執(zhí)行器，用于異步調(diào)用事件監(jiān)聽(tīng)器。
    @Nullable
    private Executor taskExecutor;

    // 可選的錯(cuò)誤處理器，用于處理在廣播事件過(guò)程中出現(xiàn)的錯(cuò)誤。
    @Nullable
    private ErrorHandler errorHandler;

    // 用于記錄日志的logger，它是延遲初始化的。
    @Nullable
    private volatile Log lazyLogger;

    // 默認(rèn)構(gòu)造函數(shù)。
    public SimpleApplicationEventMulticaster() {
    }

    // 帶有BeanFactory參數(shù)的構(gòu)造函數(shù)，通常用于更復(fù)雜的應(yīng)用上下文配置中。
    public SimpleApplicationEventMulticaster(BeanFactory beanFactory) {
        this.setBeanFactory(beanFactory);
    }

    // 設(shè)置任務(wù)執(zhí)行器。可以是任何Java Executor，比如Spring的SimpleAsyncTaskExecutor或Java的FixedThreadPool。
    public void setTaskExecutor(@Nullable Executor taskExecutor) {
        this.taskExecutor = taskExecutor;
    }

    // 獲取當(dāng)前設(shè)置的任務(wù)執(zhí)行器。
    @Nullable
    protected Executor getTaskExecutor() {
        return this.taskExecutor;
    }

    // 設(shè)置錯(cuò)誤處理器。
    public void setErrorHandler(@Nullable ErrorHandler errorHandler) {
        this.errorHandler = errorHandler;
    }

    // 獲取當(dāng)前設(shè)置的錯(cuò)誤處理器。
    @Nullable
    protected ErrorHandler getErrorHandler() {
        return this.errorHandler;
    }

    // 這是廣播事件的主要方法。它首先解析事件的類(lèi)型，然后調(diào)用具有額外參數(shù)的重載方法。
    public void multicastEvent(ApplicationEvent event) {
        this.multicastEvent(event, this.resolveDefaultEventType(event));
    }

    // 這個(gè)方法是真正執(zhí)行廣播操作的方法。
    public void multicastEvent(ApplicationEvent event, @Nullable ResolvableType eventType) {
        // 確定事件類(lèi)型。
        ResolvableType type = (eventType != null) ? eventType : this.resolveDefaultEventType(event);
        // 獲取任務(wù)執(zhí)行器。
        Executor executor = this.getTaskExecutor();
        // 獲取匹配此事件類(lèi)型的所有監(jiān)聽(tīng)器。
        Iterator<ApplicationListener<?>> listeners = this.getApplicationListeners(event, type).iterator();

        // 遍歷每個(gè)監(jiān)聽(tīng)器并調(diào)用它。
        while(listeners.hasNext()) {
            ApplicationListener<?> listener = listeners.next();
            // 如果有設(shè)置任務(wù)執(zhí)行器，則異步調(diào)用監(jiān)聽(tīng)器。
            if (executor != null) {
                executor.execute(() -> this.invokeListener(listener, event));
            } else {
                // 如果沒(méi)有設(shè)置任務(wù)執(zhí)行器，則同步調(diào)用監(jiān)聽(tīng)器。
                this.invokeListener(listener, event);
            }
        }
    }

    // 為給定的事件解析默認(rèn)的事件類(lèi)型。
    private ResolvableType resolveDefaultEventType(ApplicationEvent event) {
        return ResolvableType.forInstance(event);
    }

    // 調(diào)用指定的監(jiān)聽(tīng)器來(lái)處理給定的事件，并根據(jù)需要處理錯(cuò)誤。
    protected void invokeListener(ApplicationListener<?> listener, ApplicationEvent event) {
        // 獲取當(dāng)前的錯(cuò)誤處理器。
        ErrorHandler errorHandler = this.getErrorHandler();
        if (errorHandler != null) {
            try {
                // 嘗試調(diào)用監(jiān)聽(tīng)器。
                this.doInvokeListener(listener, event);
            } catch (Throwable ex) {
                // 如果出現(xiàn)錯(cuò)誤，使用錯(cuò)誤處理器處理。
                errorHandler.handleError(ex);
            }
        } else {
            // 如果沒(méi)有設(shè)置錯(cuò)誤處理器，則直接調(diào)用監(jiān)聽(tīng)器。
            this.doInvokeListener(listener, event);
        }
    }

    // 直接調(diào)用監(jiān)聽(tīng)器，捕獲任何類(lèi)型不匹配的異常。
    private void doInvokeListener(ApplicationListener listener, ApplicationEvent event) {
        try {
            listener.onApplicationEvent(event);
        } catch (ClassCastException ex) {
            // 捕獲類(lèi)型轉(zhuǎn)換異常，并根據(jù)需要進(jìn)行處理。
            // 這可以確保如果監(jiān)聽(tīng)器不能處理特定類(lèi)型的事件，不會(huì)導(dǎo)致整個(gè)廣播操作失敗。
            String msg = ex.getMessage();
            if (msg != null && !this.matchesClassCastMessage(msg, event.getClass()) && (!(event instanceof PayloadApplicationEvent) || !this.matchesClassCastMessage(msg, ((PayloadApplicationEvent)event).getPayload().getClass()))) {
                throw ex;
            }
            
            // 在預(yù)期情況下捕獲并記錄異常，而不是拋出它。
            Log loggerToUse = this.lazyLogger;
            if (loggerToUse == null) {
                loggerToUse = LogFactory.getLog(this.getClass());
                this.lazyLogger = loggerToUse;
            }
            if (loggerToUse.isTraceEnabled()) {
                loggerToUse.trace("Non-matching event type for listener: " + listener, ex);
            }
        }
    }

    // 根據(jù)給定的類(lèi)型錯(cuò)誤消息和事件類(lèi)來(lái)檢查ClassCastException是否是預(yù)期的。
    private boolean matchesClassCastMessage(String classCastMessage, Class<?> eventClass) {
        if (classCastMessage.startsWith(eventClass.getName())) {
            return true;
        } else if (classCastMessage.startsWith(eventClass.toString())) {
            return true;
        } else {
            int moduleSeparatorIndex = classCastMessage.indexOf(47);
            return moduleSeparatorIndex != -1 && classCastMessage.startsWith(eventClass.getName(), moduleSeparatorIndex + 1);
        }
    }
}

// 這個(gè)方法是真正執(zhí)行廣播操作的方法。
    public void multicastEvent(ApplicationEvent event, @Nullable ResolvableType eventType) {
        // 確定事件類(lèi)型。
        ResolvableType type = (eventType != null) ? eventType : this.resolveDefaultEventType(event);
		......
		// 獲取匹配此事件類(lèi)型的所有監(jiān)聽(tīng)器。
        Iterator<ApplicationListener<?>> listeners = this.getApplicationListeners(event, type).iterator();
        ......
    }
-----------------------------------
?著作權(quán)歸作者所有：來(lái)自51CTO博客作者華為云開(kāi)發(fā)者聯(lián)盟的原創(chuàng)作品，請(qǐng)聯(lián)系作者獲取轉(zhuǎn)載授權(quán)，否則將追究法律責(zé)任
掌握Spring事件監(jiān)聽(tīng)器的內(nèi)部邏輯與實(shí)現(xiàn)
https://blog.51cto.com/u_15214399/8112689

public class Sample {
    private List<String> names;
}

ResolvableType t = ResolvableType.forField(Sample.class.getDeclaredField("names"));
Class<?> genericType = t.getGeneric(0).resolve(); // 得到 String.class

ApplicationEvent event = new MyCustomEvent(this, "data");
applicationContext.publishEvent(event);

public class MyListener implements ApplicationListener<MyCustomEvent> {
    @Override
    public void onApplicationEvent(MyCustomEvent event) {
        // handle the event
    }
}

protected Collection<ApplicationListener<?>> getApplicationListeners(ApplicationEvent event, ResolvableType eventType) {
    // 獲取事件來(lái)源對(duì)象
    Object source = event.getSource();
    // 判斷事件來(lái)源對(duì)象是否為null，是則返回null，否則返回事件來(lái)源對(duì)象的類(lèi)
    Class<?> sourceType = source != null ? source.getClass() : null;
    // 使用事件類(lèi)型和源類(lèi)型作為緩存鍵
    AbstractApplicationEventMulticaster.ListenerCacheKey cacheKey = new AbstractApplicationEventMulticaster.ListenerCacheKey(eventType, sourceType);
    // 初始化一個(gè)新的監(jiān)聽(tīng)器檢索器為null
    AbstractApplicationEventMulticaster.CachedListenerRetriever newRetriever = null;
    // 嘗試從緩存中使用鍵取得一個(gè)已存在的檢索器
    AbstractApplicationEventMulticaster.CachedListenerRetriever existingRetriever = (AbstractApplicationEventMulticaster.CachedListenerRetriever)this.retrieverCache.get(cacheKey);
    // 如果沒(méi)有從緩存中獲取到檢索器，并且滿(mǎn)足緩存安全性條件
    if (existingRetriever == null && (this.beanClassLoader == null || ClassUtils.isCacheSafe(event.getClass(), this.beanClassLoader) && (sourceType == null || ClassUtils.isCacheSafe(sourceType, this.beanClassLoader)))) {
        // 創(chuàng)建一個(gè)新的檢索器
        newRetriever = new AbstractApplicationEventMulticaster.CachedListenerRetriever();
        // 嘗試將新檢索器添加到緩存中
        existingRetriever = (AbstractApplicationEventMulticaster.CachedListenerRetriever)this.retrieverCache.putIfAbsent(cacheKey, newRetriever);
        // 如果緩存中已經(jīng)有了一個(gè)值（由于并發(fā)的原因），則將新檢索器設(shè)回null
        if (existingRetriever != null) {
            newRetriever = null;
        }
    }

    // 如果有現(xiàn)有的檢索器
    if (existingRetriever != null) {
        // 嘗試從檢索器中獲取監(jiān)聽(tīng)器集合
        Collection<ApplicationListener<?>> result = existingRetriever.getApplicationListeners();
        // 如果結(jié)果不為null，則直接返回
        if (result != null) {
            return result;
        }
    }

    // 如果上述步驟都沒(méi)有返回，調(diào)用retrieveApplicationListeners進(jìn)行實(shí)際的監(jiān)聽(tīng)器檢索
    return this.retrieveApplicationListeners(eventType, sourceType, newRetriever);
}

private Collection<ApplicationListener<?>> retrieveApplicationListeners(ResolvableType eventType, @Nullable Class<?> sourceType, @Nullable AbstractApplicationEventMulticaster.CachedListenerRetriever retriever) {
    // 初始化一個(gè)空的監(jiān)聽(tīng)器列表
    List<ApplicationListener<?>> allListeners = new ArrayList();
    // 若retriever非null，則初始化集合來(lái)保存過(guò)濾出來(lái)的監(jiān)聽(tīng)器和Bean名
    Set<ApplicationListener<?>> filteredListeners = retriever != null ? new LinkedHashSet() : null;
    Set<String> filteredListenerBeans = retriever != null ? new LinkedHashSet() : null;
    LinkedHashSet listeners;
    LinkedHashSet listenerBeans;
    // 同步從defaultRetriever中獲取已注冊(cè)的監(jiān)聽(tīng)器和其Bean名稱(chēng)
    synchronized(this.defaultRetriever) {
        listeners = new LinkedHashSet(this.defaultRetriever.applicationListeners);
        listenerBeans = new LinkedHashSet(this.defaultRetriever.applicationListenerBeans);
    }

    // 遍歷所有的監(jiān)聽(tīng)器
    for (ApplicationListener<?> listener : listeners) {
        // 檢查該監(jiān)聽(tīng)器是否支持此事件類(lèi)型和源類(lèi)型
        if (this.supportsEvent(listener, eventType, sourceType)) {
            if (retriever != null) {
                // 如果支持并且retriever非null，添加到過(guò)濾監(jiān)聽(tīng)器集合
                filteredListeners.add(listener);
            }
            // 將支持的監(jiān)聽(tīng)器添加到allListeners列表
            allListeners.add(listener);
        }
    }

    // 如果存在監(jiān)聽(tīng)器Bean名稱(chēng)
    if (!listenerBeans.isEmpty()) {
        ConfigurableBeanFactory beanFactory = this.getBeanFactory();
        for (String listenerBeanName : listenerBeans) {
            try {
                // 檢查Bean工廠(chǎng)中的Bean是否支持該事件
                if (this.supportsEvent(beanFactory, listenerBeanName, eventType)) {
                    ApplicationListener<?> listener = (ApplicationListener)beanFactory.getBean(listenerBeanName, ApplicationListener.class);
                    // 再次檢查確保Bean實(shí)例支持事件，并且它還沒(méi)有被加入allListeners列表
                    if (!allListeners.contains(listener) && this.supportsEvent(listener, eventType, sourceType)) {
                        if (retriever != null) {
                            // 若該Bean是單例并且retriever非null，添加到過(guò)濾監(jiān)聽(tīng)器集合
                            if (beanFactory.isSingleton(listenerBeanName)) {
                                filteredListeners.add(listener);
                            } else {
                                filteredListenerBeans.add(listenerBeanName);
                            }
                        }
                        // 添加到allListeners列表
                        allListeners.add(listener);
                    }
                } else {
                    // 若不支持該事件，從allListeners中移除該Bean
                    Object listener = beanFactory.getSingleton(listenerBeanName);
                    if (retriever != null) {
                        filteredListeners.remove(listener);
                    }
                    allListeners.remove(listener);
                }
            } catch (NoSuchBeanDefinitionException e) {
                // 若Bean不存在，直接繼續(xù)下一個(gè)
            }
        }
    }

    // 對(duì)allListeners列表進(jìn)行排序，確保監(jiān)聽(tīng)器的執(zhí)行順序
    AnnotationAwareOrderComparator.sort(allListeners);
    // 如果retriever非null，更新其內(nèi)部集合以后續(xù)使用
    if (retriever != null) {
        if (filteredListenerBeans.isEmpty()) {
            retriever.applicationListeners = new LinkedHashSet(allListeners);
            retriever.applicationListenerBeans = filteredListenerBeans;
        } else {
            retriever.applicationListeners = filteredListeners;
            retriever.applicationListenerBeans = filteredListenerBeans;
        }
    }

    // 返回allListeners作為結(jié)果
    return allListeners;
}
-----------------------------------
?著作權(quán)歸作者所有：來(lái)自51CTO博客作者華為云開(kāi)發(fā)者聯(lián)盟的原創(chuàng)作品，請(qǐng)聯(lián)系作者獲取轉(zhuǎn)載授權(quán)，否則將追究法律責(zé)任
掌握Spring事件監(jiān)聽(tīng)器的內(nèi)部邏輯與實(shí)現(xiàn)
https://blog.51cto.com/u_15214399/8112689

AbstractApplicationEventMulticaster.CachedListenerRetriever existingRetriever = 
    (AbstractApplicationEventMulticaster.CachedListenerRetriever)this.retrieverCache.get(cacheKey);

if (existingRetriever == null && (this.beanClassLoader == null || ...)) {
    ...
}

newRetriever = new AbstractApplicationEventMulticaster.CachedListenerRetriever();
existingRetriever = (AbstractApplicationEventMulticaster.CachedListenerRetriever)this.retrieverCache.putIfAbsent(cacheKey, newRetriever);

listeners = new LinkedHashSet(this.defaultRetriever.applicationListeners);
for (ApplicationListener<?> listener : listeners) {
    if (this.supportsEvent(listener, eventType, sourceType)) {
        ... // 添加到篩選出來(lái)的監(jiān)聽(tīng)器列表
    }
}

if (!listenerBeans.isEmpty()) {
    ConfigurableBeanFactory beanFactory = this.getBeanFactory();
    for (String listenerBeanName : listenerBeans) {
        ... // 檢查并添加到篩選出來(lái)的監(jiān)聽(tīng)器列表
    }
}

AnnotationAwareOrderComparator.sort(allListeners);