// 承載業(yè)務(wù)數(shù)據(jù)的載體，所有 Spring 應(yīng)用事件的基類，必須由具體事件類繼承
publicabstractclass ApplicationEvent extends EventObject {

    privatestaticfinallong serialVersionUID = 7099057708183571937L;

    // 記錄事件發(fā)生的時間戳（毫秒級精度）
    privatefinallong timestamp;

    public ApplicationEvent(Object source) {
        super(source);
        this.timestamp = System.currentTimeMillis();
    }

    public ApplicationEvent(Object source, Clock clock) {
        super(source);
        this.timestamp = clock.millis();
    }

    public final long getTimestamp() {
        returnthis.timestamp;
    }
}

/**
 * 封裝事件發(fā)布功能的核心接口，同時也是 ApplicationContext 的父接口
 * @FunctionalInterface 標記函數(shù)式接口，支持 lambda 表達式實現(xiàn)
 */
@FunctionalInterface
public interface ApplicationEventPublisher {

    /**
     * 發(fā)布 ApplicationEvent 類型的事件（如 ContextRefreshedEvent）
     * 底層會將事件對象強轉(zhuǎn)為 Object 類型，然后調(diào)用重載方法統(tǒng)一處理
     */
    default void publishEvent(ApplicationEvent event) {
        publishEvent((Object) event);
    }

    /**
     * 通用事件發(fā)布方法，支持任意對象類型的事件
     * 若參數(shù)非 ApplicationEvent 類型，Spring 會將其封裝為 PayloadApplicationEvent
     * 事件最終通過 ApplicationEventMulticaster 廣播給匹配的監(jiān)聽器
     * 官方設(shè)計提示：耗時操作建議監(jiān)聽器自行實現(xiàn)異步處理
     */
    void publishEvent(Object event);
}

/**
 * 訂閱并處理特定事件，基于觀察者模式，繼承標準 EventListener 接口
 */
@FunctionalInterface
public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {

    // 當匹配類型的事件發(fā)布時觸發(fā)
    void onApplicationEvent(E event);
}

/**
 * 事件廣播器接口，用于管理監(jiān)聽器注冊表，實現(xiàn)事件路由。
 * 通常由 Spring 上下文內(nèi)部實現(xiàn)，作為事件發(fā)布委托組件。
 */
publicinterface ApplicationEventMulticaster {

    /**
     * 添加監(jiān)聽器實例（編程式注冊）
     */
    void addApplicationListener(ApplicationListener<?> listener);

    /**
     * 通過 Bean 名稱添加監(jiān)聽器（適用于容器管理的 Bean）
     */
    void addApplicationListenerBean(String listenerBeanName);

    /**
     * 移除指定監(jiān)聽器實例
     */
    void removeApplicationListener(ApplicationListener<?> listener);

    /**
     * 通過Bean名稱移除監(jiān)聽器
     */
    void removeApplicationListenerBean(String listenerBeanName);

    /**
     * 清空所有注冊的監(jiān)聽器實例和Bean名稱
     */
    void removeAllListeners();

    /**
     * 廣播事件（自動推斷事件類型）
     */
    void multicastEvent(ApplicationEvent event);

    /**
     * 廣播事件（顯式指定事件類型，支持泛型解析）
     */
    void multicastEvent(ApplicationEvent event, @Nullable ResolvableType eventType);
}

@Getter
public class UserRegisterEvent extends ApplicationEvent {
    private final String username;
    public UserRegisterEvent(Object source, String username) {
        super(source);
        this.username = username;
    }
}

// 方式1：實現(xiàn) ApplicationListener 接口
@Component
publicclass EmailListener implements ApplicationListener<UserRegisterEvent> {
    @Override
    public void onApplicationEvent(UserRegisterEvent event) {
        sendEmail(event.getUsername());
    }
}

// 方式2：使用 @EventListener 注解
@Component
publicclass LogsListener {
    @EventListener
    public void handleEvent(UserRegisterEvent event) {
        addLogs(event.getUsername());
    }
}

@Service
public class UserService {
    @Resource
    private ApplicationContext context;

    public void register(String username) {
        // 業(yè)務(wù)邏輯 ......
        context.publishEvent(new UserRegisterEvent(this, username));
    }
}

public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory,
  MessageSource, ApplicationEventPublisher, ResourcePatternResolver {}

@Override
public void publishEvent(ApplicationEvent event) {
    publishEvent(event, null);
}

protected void publishEvent(Object event, @Nullable ResolvableType eventType) {
    ......

    if (this.earlyApplicationEvents != null) {
        this.earlyApplicationEvents.add(applicationEvent);
    } else {
        // 獲取事件廣播器并將事件路由至對應(yīng)的監(jiān)聽器上
        getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
    }

    ......
}

public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        ......
        // 預(yù)備刷新 beanFactory
        prepareBeanFactory(beanFactory);

        try {
            // 注冊 bean 后置處理器
            registerBeanPostProcessors(beanFactory);

            // Initialize event multicaster for this context.
            // 初始化事件廣播器
            initApplicationEventMulticaster();

            // 注冊事件監(jiān)聽器
            registerListeners();

            // 實例化所有非懶加載的單例 bean
            finishBeanFactoryInitialization(beanFactory);

            // 發(fā)布相關(guān)事件(ContextRefreshedEvent)
            finishRefresh();
        } catch (BeansException ex) {
            ......
        } finally {
            ......
        }
    }
}

protected void initApplicationEventMulticaster() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    // 判斷容器中是否有名為 applicationEventMulticaster 的廣播器，有的話使用這個進行初始化
    if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
        this.applicationEventMulticaster =
                beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
        }
    }
    else {
        // 沒有的話，初始化一個 SimpleApplicationEventMulticaster，并注冊到容器中
        this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
        beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
    }
}

protected void registerListeners() {
    /**
     * 這里 getApplicationListeners() 是獲取的成員變量 applicationListeners 的值
     * 是指通過 context.addApplicationListener(new EmailListener())編程式手動添加的
     * 或者是通過 spring.factories 自動裝配進來的 Listener
     */
    for (ApplicationListener<?> listener : getApplicationListeners()) {
        getApplicationEventMulticaster().addApplicationListener(listener);
    }

    /**
     * 獲取容器中所有實現(xiàn) ApplicationListener 接口的 Bean 的名稱
     * 這里不對 bean 進行初始化，交由 bean 的后置處理器在初始化后實際注冊
     * 此處數(shù)組中的 beanName 不包含上述 getApplicationListeners() 方法中獲取到的 ApplicationListener
     */
    String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
    for (String listenerBeanName : listenerBeanNames) {
        getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
    }

    // 處理早期應(yīng)用事件（在事件廣播器初始化前緩存的事件）
    Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
    this.earlyApplicationEvents = null;
    // 如果存在早期事件，通過多播器廣播這些事件
    if (!CollectionUtils.isEmpty(earlyEventsToProcess)) {
        for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
            getApplicationEventMulticaster().multicastEvent(earlyEvent);
        }
    }
}

public Object postProcessAfterInitialization(Object bean, String beanName) {
    if (bean instanceof ApplicationListener) {
        // registerListeners() 階段可能會檢測不到某些監(jiān)聽器（例如延遲初始化的 Bean 或動態(tài)代理生成的 Bean）
        // 從緩存中獲取該 Bean 是否為單例的標記
        Boolean flag = this.singletonNames.get(beanName);
        if (Boolean.TRUE.equals(flag)) {
            // 將 Bean 注冊為應(yīng)用監(jiān)聽器
            this.applicationContext.addApplicationListener((ApplicationListener<?>) bean);
        }
        elseif (Boolean.FALSE.equals(flag)) {
            // 如果是非單例 Bean，移除該 Bean 的標記，避免后續(xù)重復(fù)處理
            this.singletonNames.remove(beanName);
        }
    }
    return bean;
}

protected void publishEvent(Object event, @Nullable ResolvableType eventType) {
    ......

    if (this.earlyApplicationEvents != null) {
        this.earlyApplicationEvents.add(applicationEvent);
    } else {
        // 獲取事件廣播器并將事件路由至對應(yīng)的監(jiān)聽器上
        getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
    }

    ......
}

public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
    // 推斷事件類型
    ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
    // 獲取配置的異步執(zhí)行器
    Executor executor = getTaskExecutor();
    // 獲取所有匹配的監(jiān)聽器
    for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {
        // 如果配置了異步執(zhí)行器，則異步執(zhí)行
        if (executor != null) {
            executor.execute(() -> invokeListener(listener, event));
        }
        else {
            // 同步執(zhí)行監(jiān)聽器
            invokeListener(listener, event);
        }
    }
}

protected void invokeListener(ApplicationListener<?> listener, ApplicationEvent event) {
    ErrorHandler errorHandler = getErrorHandler();
    if (errorHandler != null) {
        try {
            // 執(zhí)行監(jiān)聽器
            doInvokeListener(listener, event);
        }
        catch (Throwable err) {
            errorHandler.handleError(err);
        }
    }
    else {
        doInvokeListener(listener, event);
    }
}

private void doInvokeListener(ApplicationListener listener, ApplicationEvent event) {
    try {
        // 調(diào)用監(jiān)聽器接口方法
        listener.onApplicationEvent(event);
    }
    catch (ClassCastException ex) {
        ......
    }
}

@Component
publicclass UserEventListener {

    // 默認處理：所有注冊事件均觸發(fā)
    @EventListener
    public void handleDefault(UserRegisterEvent event) {
        System.out.println("記錄日志: 用戶 " + event.getUsername() + " 注冊成功");
    }

    // 指定渠道處理：僅當 channel=web 時觸發(fā)
    @EventListener(condition = "#event.channel == 'web'")
    public void handleWebChannel(UserRegisterEvent event) {
        System.out.println("推送站內(nèi)消息至用戶: " + event.getUsername());
    }
}