package com.lazy.snail;
 ?
 import lombok.Getter;
 import org.springframework.context.ApplicationEvent;
 ?
 /**
  * @ClassName UserRegisteredEvent
  * @Description TODO
  * @Author lazysnail
  * @Date 2024/11/8 10:37
  * @Version 1.0
  */
 @Getter
 public class UserRegisteredEvent extends ApplicationEvent {
     private final String username;
 ?
     public UserRegisteredEvent(Object source, String username) {
         super(source);
         this.username = username;
     }
 }

 package com.lazy.snail;
 ?
 import org.springframework.context.event.EventListener;
 import org.springframework.stereotype.Component;
 ?
 /**
  * @ClassName UserRegisteredListener
  * @Description TODO
  * @Author lazysnail
  * @Date 2024/11/8 10:36
  * @Version 1.0
  */
 @Component
 public class UserRegisteredListener {
     @EventListener
     public void handleUserRegisterEvent(UserRegisteredEvent event) {
         System.out.println("用戶注冊成功，發(fā)送郵件通知");
     }
 }

 package com.lazy.snail;
 ?
 import org.springframework.context.ApplicationEventPublisher;
 import org.springframework.stereotype.Service;
 ?
 /**
  * @ClassName UserService
  * @Description TODO
  * @Author lazysnail
  * @Date 2024/11/8 10:37
  * @Version 1.0
  */
 @Service
 public class UserService {
     private final ApplicationEventPublisher eventPublisher;
 ?
     public UserService(ApplicationEventPublisher eventPublisher) {
         this.eventPublisher = eventPublisher;
     }
 ?
     public void registerUser(String username) {
         // 用戶注冊邏輯
         System.out.println("Registering user: " + username);
 ?
         // 發(fā)布用戶注冊事件
         eventPublisher.publishEvent(new UserRegisteredEvent(this, username));
     }
 }

 package com.lazy.snail;
 ?
 import lombok.extern.slf4j.Slf4j;
 import org.junit.jupiter.api.Test;
 import org.springframework.context.ConfigurableApplicationContext;
 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 ?
 @Slf4j
 public class SpringTest {
 ?
     @Test
     void test() {
         ConfigurableApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
         context.getBean(UserService.class).registerUser("lazysnail");
     }
 }

 public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
             BeanDefinitionRegistry registry, @Nullable Object source) {
     // 省略部分代碼...
     
     // 事件監(jiān)聽方法處理器
     if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
         RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
         def.setSource(source);
         beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
     }
     
     // 默認事件監(jiān)聽工廠
     if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
         RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
         def.setSource(source);
         beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
     }
 ?
     return beanDefs;
 }

 // EventListenerMethodProcessor
 public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
     this.beanFactory = beanFactory;
 ?
     Map<String, EventListenerFactory> beans = beanFactory.getBeansOfType(EventListenerFactory.class, false, false);
     List<EventListenerFactory> factories = new ArrayList<>(beans.values());
     AnnotationAwareOrderComparator.sort(factories);
     this.eventListenerFactories = factories;
 }

 // AbstractApplicationContext
 public void refresh() throws BeansException, IllegalStateException {
     // 為容器初始化事件廣播器
     initApplicationEventMulticaster();
 }

 // AbstractApplicationContext
 protected void initApplicationEventMulticaster() {
     this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
     beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
     if (logger.isTraceEnabled()) {
         logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +
                 "[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
     }
 }

 private class DefaultListenerRetriever {
 ?
     public final Set<ApplicationListener<?>> applicationListeners = new LinkedHashSet<>();
 ?
     public final Set<String> applicationListenerBeans = new LinkedHashSet<>();
 }

 // DefaultListableBeanFactory
 public void preInstantiateSingletons() throws BeansException {
     // 省略部分代碼...
     
     // EventListenerMethodProcessor
     for (String beanName : beanNames) {
         Object singletonInstance = getSingleton(beanName);
         if (singletonInstance instanceof SmartInitializingSingleton) {
             StartupStep smartInitialize = this.getApplicationStartup().start("spring.beans.smart-initialize")
                     .tag("beanName", beanName);
             SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
             if (System.getSecurityManager() != null) {
                 AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                     smartSingleton.afterSingletonsInstantiated();
                     return null;
                 }, getAccessControlContext());
             } else {
                 // 單例實例化后處理
                 smartSingleton.afterSingletonsInstantiated();
             }
             smartInitialize.end();
         }
     }
 }

 // EventListenerMethodProcessor
 public void afterSingletonsInstantiated() {
     ConfigurableListableBeanFactory beanFactory = this.beanFactory;
     Assert.state(this.beanFactory != null, "No ConfigurableListableBeanFactory set");
     String[] beanNames = beanFactory.getBeanNamesForType(Object.class);
     // 處理UserRegisteredListener
     for (String beanName : beanNames) {
         // 省略部分代碼...
         processBean(beanName, type);
     }
 }
 ?
 private void processBean(final String beanName, final Class<?> targetType) {
     if (!this.nonAnnotatedClasses.contains(targetType) &&
             AnnotationUtils.isCandidateClass(targetType, EventListener.class) &&
             !isSpringContainerClass(targetType)) {
 ?
         Map<Method, EventListener> annotatedMethods = null;
         // 省略部分代碼...
         
         // @EventListener注解的方法（注解上的屬性）
         annotatedMethods = MethodIntrospector.selectMethods(targetType,
                     (MethodIntrospector.MetadataLookup<EventListener>) method ->
                             AnnotatedElementUtils.findMergedAnnotation(method, EventListener.class));
 ?
         if (CollectionUtils.isEmpty(annotatedMethods)) {
             this.nonAnnotatedClasses.add(targetType);
             if (logger.isTraceEnabled()) {
                 logger.trace("No @EventListener annotations found on bean class: " + targetType.getName());
             }
         } else {
             // Non-empty set of methods
             ConfigurableApplicationContext context = this.applicationContext;
             Assert.state(context != null, "No ApplicationContext set");
             List<EventListenerFactory> factories = this.eventListenerFactories;
             Assert.state(factories != null, "EventListenerFactory List not initialized");
             for (Method method : annotatedMethods.keySet()) {
                 for (EventListenerFactory factory : factories) {
                     if (factory.supportsMethod(method)) {
                         Method methodToUse = AopUtils.selectInvocableMethod(method, context.getType(beanName));
                         // 事件監(jiān)聽工廠創(chuàng)建應(yīng)用監(jiān)聽器 ApplicationListenerMethodAdapter
                         ApplicationListener<?> applicationListener =
                                 factory.createApplicationListener(beanName, targetType, methodToUse);
                         if (applicationListener instanceof ApplicationListenerMethodAdapter) {
                             ((ApplicationListenerMethodAdapter) applicationListener).init(context, this.evaluator);
                         }
                         // 添加到應(yīng)用上下文
                         context.addApplicationListener(applicationListener);
                         break;
                     }
                 }
             }
         }
     }
 }

 // AbstractApplicationContext
 protected void publishEvent(Object event, @Nullable ResolvableType eventType) {
     getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
 }

 // SimpleApplicationEventMulticaster
 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) {
             executor.execute(() -> invokeListener(listener, event));
         } else {
             invokeListener(listener, event);
         }
     }
 }

 /**
  * 根據(jù)給定的事件、源（我理解是容器）檢索監(jiān)聽器
  * 
  */
 // AbstractApplicationEventMulticaster
 private Collection<ApplicationListener<?>> retrieveApplicationListeners(
             ResolvableType eventType, @Nullable Class<?> sourceType, @Nullable CachedListenerRetriever retriever) {
 ?
     List<ApplicationListener<?>> allListeners = new ArrayList<>();
     Set<ApplicationListener<?>> filteredListeners = (retriever != null ? new LinkedHashSet<>() : null);
     Set<String> filteredListenerBeans = (retriever != null ? new LinkedHashSet<>() : null);
 ?
     Set<ApplicationListener<?>> listeners;
     Set<String> listenerBeans;
     synchronized (this.defaultRetriever) {
         // 默認檢索器中獲取應(yīng)用監(jiān)聽，監(jiān)聽已經(jīng)在Spring啟動階段注冊完成
         listeners = new LinkedHashSet<>(this.defaultRetriever.applicationListeners);
         listenerBeans = new LinkedHashSet<>(this.defaultRetriever.applicationListenerBeans);
     }
 ?
     // 省略部分代碼...
 ?
     AnnotationAwareOrderComparator.sort(allListeners);
     if (retriever != null) {
         if (filteredListenerBeans.isEmpty()) {
             retriever.applicationListeners = new LinkedHashSet<>(allListeners);
             retriever.applicationListenerBeans = filteredListenerBeans;
         }
         else {
             retriever.applicationListeners = filteredListeners;
             retriever.applicationListenerBeans = filteredListenerBeans;
         }
     }
     return allListeners;
 }