Spring事件机制详解

public class MyEvent extends ApplicationEvent {
    private String name;
    public MyEvent(Object source, String name) {
        super(source);
        this.name = name;
    }

    @Override
    public String toString() {
        return "MyEvent{" +
                "name='" + name + '\'' +
                "} " + super.toString();
    }
}

@FunctionalInterface
public interface ApplicationEventPublisher {
 default void publishEvent(ApplicationEvent event) {
  publishEvent((Object) event);
 }
 void publishEvent(Object event);
}

AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(JavaConfig.class);
ctx.publishEvent(new MyEvent(new Demo(), "javaboy"));

@Component
public class MyEventListener implements ApplicationListener<MyEvent> {
    @Override
    public void onApplicationEvent(MyEvent event) {
        System.out.println("event = " + event);
    }
}

@Component
public class MyEventListener02 {
    @EventListener(value = MyEvent.class)
    public void hello(MyEvent event) {
        System.out.println("event02 = " + event);
    }
}

public interface ApplicationEventMulticaster {
 void addApplicationListener(ApplicationListener<?> listener);
 void addApplicationListenerBean(String listenerBeanName);
 void removeApplicationListener(ApplicationListener<?> listener);
 void removeApplicationListenerBean(String listenerBeanName);
 void removeApplicationListeners(Predicate<ApplicationListener<?>> predicate);
 void removeApplicationListenerBeans(Predicate<String> predicate);
 void removeAllListeners();
 void multicastEvent(ApplicationEvent event);
 void multicastEvent(ApplicationEvent event, @Nullable ResolvableType eventType);
}

protected void registerListeners() {
 // Register statically specified listeners first.
 for (ApplicationListener<?> listener : getApplicationListeners()) {
  getApplicationEventMulticaster().addApplicationListener(listener);
 }
 // Do not initialize FactoryBeans here: We need to leave all regular beans
 // uninitialized to let post-processors apply to them!
 String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
 for (String listenerBeanName : listenerBeanNames) {
  getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
 }
 // Publish early application events now that we finally have a multicaster...
 Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
 this.earlyApplicationEvents = null;
 if (!CollectionUtils.isEmpty(earlyEventsToProcess)) {
  for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
   getApplicationEventMulticaster().multicastEvent(earlyEvent);
  }
 }
}

public class Demo {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
        ctx.addApplicationListener(new MyEventListener());
        ctx.register(JavaConfig.class);
        ctx.refresh();
        ctx.publishEvent(new MyEvent(new Demo(), "javaboy"));
    }
}

@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {
 if (bean instanceof ApplicationListener<?> applicationListener) {
  Boolean flag = this.singletonNames.get(beanName);
  if (Boolean.TRUE.equals(flag)) {
   this.applicationContext.addApplicationListener(applicationListener);
  }
  else if (Boolean.FALSE.equals(flag)) {
   this.singletonNames.remove(beanName);
  }
 }
 return bean;
}

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;
  try {
   annotatedMethods = MethodIntrospector.selectMethods(targetType,
     (MethodIntrospector.MetadataLookup<EventListener>) method ->
       AnnotatedElementUtils.findMergedAnnotation(method, EventListener.class));
  }
  catch (Throwable ex) {
  }
  if (CollectionUtils.isEmpty(annotatedMethods)) {
   this.nonAnnotatedClasses.add(targetType);
  }
  else {
   // Non-empty set of methods
   ConfigurableApplicationContext context = this.applicationContext;
   List<EventListenerFactory> factories = this.eventListenerFactories;
   for (Method method : annotatedMethods.keySet()) {
    for (EventListenerFactory factory : factories) {
     if (factory.supportsMethod(method)) {
      Method methodToUse = AopUtils.selectInvocableMethod(method, context.getType(beanName));
      ApplicationListener<?> applicationListener =
        factory.createApplicationListener(beanName, targetType, methodToUse);
      if (applicationListener instanceof ApplicationListenerMethodAdapter alma) {
       alma.init(context, this.evaluator);
      }
      context.addApplicationListener(applicationListener);
      break;
     }
    }
   }
  }
 }
}

protected void initApplicationEventMulticaster() {
 ConfigurableListableBeanFactory beanFactory = getBeanFactory();
 if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
  this.applicationEventMulticaster =
    beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
 }
 else {
  this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
  beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
 }
}

@Override
public void publishEvent(ApplicationEvent event) {
 publishEvent(event, null);
}
protected void publishEvent(Object event, @Nullable ResolvableType typeHint) {
 ResolvableType eventType = null;
 // Decorate event as an ApplicationEvent if necessary
 ApplicationEvent applicationEvent;
 if (event instanceof ApplicationEvent applEvent) {
  applicationEvent = applEvent;
  eventType = typeHint;
 }
 else {
  ResolvableType payloadType = null;
  if (typeHint != null && ApplicationEvent.class.isAssignableFrom(typeHint.toClass())) {
   eventType = typeHint;
  }
  else {
   payloadType = typeHint;
  }
  applicationEvent = new PayloadApplicationEvent<>(this, event, payloadType);
 }
 // Determine event type only once (for multicast and parent publish)
 if (eventType == null) {
  eventType = ResolvableType.forInstance(applicationEvent);
  if (typeHint == null) {
   typeHint = eventType;
  }
 }
 // Multicast right now if possible - or lazily once the multicaster is initialized
 if (this.earlyApplicationEvents != null) {
  this.earlyApplicationEvents.add(applicationEvent);
 }
 else {
  getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
 }
 // Publish event via parent context as well...
 if (this.parent != null) {
  if (this.parent instanceof AbstractApplicationContext abstractApplicationContext) {
   abstractApplicationContext.publishEvent(event, typeHint);
  }
  else {
   this.parent.publishEvent(event);
  }
 }
}

@Override
public void multicastEvent(ApplicationEvent event, @Nullable ResolvableType eventType) {
 ResolvableType type = (eventType != null ? eventType : ResolvableType.forInstance(event));
 Executor executor = getTaskExecutor();
 for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {
  if (executor != null) {
   executor.execute(() -> invokeListener(listener, event));
  }
  else {
   invokeListener(listener, event);
  }
 }
}

@Bean
SimpleApplicationEventMulticaster applicationEventMulticaster() {
    SimpleApplicationEventMulticaster multicaster = new SimpleApplicationEventMulticaster();
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    //核心线程池数量
    executor.setCorePoolSize(Runtime.getRuntime().availableProcessors());
    //最大线程数量
    executor.setMaxPoolSize(Runtime.getRuntime().availableProcessors() * 5);
    //线程池的队列容量
    executor.setQueueCapacity(Runtime.getRuntime().availableProcessors() * 2);
    //线程名称的前缀
    executor.setThreadNamePrefix("javaboy-async-executor-");
    executor.initialize();
    multicaster.setTaskExecutor(executor);
    return multicaster;
}

protected Collection<ApplicationListener<?>> getApplicationListeners(
  ApplicationEvent event, ResolvableType eventType) {
 Object source = event.getSource();
 Class<?> sourceType = (source != null ? source.getClass() : null);
 ListenerCacheKey cacheKey = new ListenerCacheKey(eventType, sourceType);
 // Potential new retriever to populate
 CachedListenerRetriever newRetriever = null;
 // Quick check for existing entry on ConcurrentHashMap
 CachedListenerRetriever existingRetriever = this.retrieverCache.get(cacheKey);
 if (existingRetriever == null) {
  // Caching a new ListenerRetriever if possible
  if (this.beanClassLoader == null ||
    (ClassUtils.isCacheSafe(event.getClass(), this.beanClassLoader) &&
      (sourceType == null || ClassUtils.isCacheSafe(sourceType, this.beanClassLoader)))) {
   newRetriever = new CachedListenerRetriever();
   existingRetriever = this.retrieverCache.putIfAbsent(cacheKey, newRetriever);
   if (existingRetriever != null) {
    newRetriever = null;  // no need to populate it in retrieveApplicationListeners
   }
  }
 }
 if (existingRetriever != null) {
  Collection<ApplicationListener<?>> result = existingRetriever.getApplicationListeners();
  if (result != null) {
   return result;
  }
  // If result is null, the existing retriever is not fully populated yet by another thread.
  // Proceed like caching wasn't possible for this current local attempt.
 }
 return retrieveApplicationListeners(eventType, sourceType, newRetriever);
}

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) {
  listeners = new LinkedHashSet<>(this.defaultRetriever.applicationListeners);
  listenerBeans = new LinkedHashSet<>(this.defaultRetriever.applicationListenerBeans);
 }
 // Add programmatically registered listeners, including ones coming
 // from ApplicationListenerDetector (singleton beans and inner beans).
 for (ApplicationListener<?> listener : listeners) {
  if (supportsEvent(listener, eventType, sourceType)) {
   if (retriever != null) {
    filteredListeners.add(listener);
   }
   allListeners.add(listener);
  }
 }
 // Add listeners by bean name, potentially overlapping with programmatically
 // registered listeners above - but here potentially with additional metadata.
 if (!listenerBeans.isEmpty()) {
  ConfigurableBeanFactory beanFactory = getBeanFactory();
  for (String listenerBeanName : listenerBeans) {
   try {
    if (supportsEvent(beanFactory, listenerBeanName, eventType)) {
     ApplicationListener<?> listener =
       beanFactory.getBean(listenerBeanName, ApplicationListener.class);
     if (!allListeners.contains(listener) && supportsEvent(listener, eventType, sourceType)) {
      if (retriever != null) {
       if (beanFactory.isSingleton(listenerBeanName)) {
        filteredListeners.add(listener);
       }
       else {
        filteredListenerBeans.add(listenerBeanName);
       }
      }
      allListeners.add(listener);
     }
    }
    else {
     // Remove non-matching listeners that originally came from
     // ApplicationListenerDetector, possibly ruled out by additional
     // BeanDefinition metadata (e.g. factory method generics) above.
     Object listener = beanFactory.getSingleton(listenerBeanName);
     if (retriever != null) {
      filteredListeners.remove(listener);
     }
     allListeners.remove(listener);
    }
   }
   catch (NoSuchBeanDefinitionException ex) {
    // Singleton listener instance (without backing bean definition) disappeared -
    // probably in the middle of the destruction phase
   }
  }
 }
 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;
}