1.将@

The EventListener method is converted to

ApplicationListener sample

2. Implement

BeanFactoryPostProcessor is used for retrieval

EventListenerFactory

Avoid AOP enhancements, EventListenerFactory

Public interface SmartInitializingSingleton {/ * * * instantiation completed calls, ensure that all normal singleton Bean is created call ListableBeanFactory *#getBeansOfType has no side effects* Note: * This callback is not triggered for lazy-loaded singleton beans. * And other scoped beans will not trigger this callback. * Use with caution and should only be used for boot functions. */ void afterSingletonsInstantiated(); }Copy the code

Public class EventListenerMethodProcessor {/ / the other omitted private void processBean (final String beanName, final class <? > targetType) {if(! this.nonAnnotatedClasses.contains(targetType) && ! targetType.getName().startsWith("java") &&! isSpringContainerClass(targetType)) { Map<Method, EventListener> annotatedMethods = null; Try {/ / find out all the EventListener annotation methods annotatedMethods = MethodIntrospector. SelectMethods (targetType, (MethodIntrospector.MetadataLookup<EventListener>) method -> AnnotatedElementUtils.findMergedAnnotation(method, EventListener.class)); } catch (Throwable ex) { // An unresolvabletype in a method signature, probably from a lazy bean - let's ignore it. if (logger.isDebugEnabled()) { logger.debug("Could not resolve methods for bean with name '" + beanName + "'", ex); } } 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
         
           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)); / / by converting EventListenerFactory ApplicationListenerMethodAdapter ApplicationListener 
           applicationListener = factory.createApplicationListener(beanName, targetType, methodToUse); if (applicationListener instanceof ApplicationListenerMethodAdapter) { ((ApplicationListenerMethodAdapter) applicationListener).init(context, this.evaluator); } // Register the event listener in the application context. context.addApplicationListener(applicationListener); break; } } } if (logger.isDebugEnabled()) { logger.debug(annotatedMethods.size() + " @EventListener methods processed on bean '
         " + beanName + "': " + annotatedMethods); } } } } }Copy the code

ApplicationListenerMethodAdapter,

• The logic of this method is to take the method at @EventListener,
• through
  EventListenerFactory into

  ApplicationListenerMethodAdapter,

• The event listener is registered in the live context.

Spring’s broadcaster

@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) { executor.execute(() -> invokeListener(listener, event)); }else{ invokeListener(listener, event); }}}Copy the code

protected Collection<ApplicationListener<? >> getApplicationListeners( ApplicationEvent event, ResolvableType eventType) { Objectsource= event.getSource(); Class<? >sourceType = (source! = null ? source.getClass() : null); ListenerCacheKey cacheKey = new ListenerCacheKey(eventType,sourceType);

   // Quick check for existing entry on ConcurrentHashMap...
   ListenerRetriever retriever = this.retrieverCache.get(cacheKey);
   if(retriever ! = null) {return retriever.getApplicationListeners();
   }

   if (this.beanClassLoader == null ||
         (ClassUtils.isCacheSafe(event.getClass(), this.beanClassLoader) &&
               (sourceType == null || ClassUtils.isCacheSafe(sourceType, this.beanClassLoader)))) {
      // Fully synchronized building and caching of a ListenerRetriever
      synchronized (this.retrievalMutex) {
         retriever = this.retrieverCache.get(cacheKey);
         if(retriever ! = null) {return retriever.getApplicationListeners();
         }
         retriever = new ListenerRetriever(true); Collection<ApplicationListener<? >> listeners = retrieveApplicationListeners(eventType,sourceType, retriever);
         this.retrieverCache.put(cacheKey, retriever);
         returnlisteners; }}else {
      // No ListenerRetriever caching -> no synchronization necessary
      return retrieveApplicationListeners(eventType, sourceType, null); }}Copy the code

private void invokeAwareInterfaces(Object bean) {
   if(bean instanceof EnvironmentAware) { ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());  }if (bean instanceof EmbeddedValueResolverAware) {
      ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
   }
   if (bean instanceof ResourceLoaderAware) {
      ((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
   }
   if (bean instanceof ApplicationEventPublisherAware) {
      ((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
   }
   if (bean instanceof MessageSourceAware) {
      ((MessageSourceAware) bean).setMessageSource(this.applicationContext);
   }
   if(bean instanceof ApplicationContextAware) { ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext); }}Copy the code

This section describes Spring Boot events

Springboot event

Spring Boot event listener

Spring Boot broadcaster