这次终于把Spring的监听器讲明白了

Posted Java鱼仔

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了这次终于把Spring的监听器讲明白了相关的知识,希望对你有一定的参考价值。

(一)Spring中的监听器

监听器可以在使用过程时监听某些事件的发生,然后对这些事件做出响应处理。监听器对应用场景很多,用户的每一个操作都可以被定义为一个事件,通过监听器就能对某些业务场景中的事件进行监听。

Spring中提供了ApplicationListener监听事件,本文会从应用出发讲解Spring的监听器,并逐步深入到源码之中。

(二)监听器的使用

首先自定义一个事件,只需要继承 ApplicationEvent 就可以创建一个自己的事件。

public class MyApplicationEvent extends ApplicationEvent 
    public MyApplicationEvent(Object source) 
        super(source);
    

接着定义一个事件监听器,实现当监听到事件后在控制台输出一条消息。

@Component
public class MyListener implements ApplicationListener<MyApplicationEvent> 
    @Override
    public void onApplicationEvent(MyApplicationEvent applicationEvent) 
        System.out.println("事件:"+applicationEvent.toString());
    

在配置类中增加包扫描地址。

@Configuration
@ComponentScan(basePackages = "com.javayz.listenerDemo")
public class MainConfig 

最后在启动容器时发布一条事件,观察结果

public class Application 
    public static void main(String[] args) 
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfig.class);
        context.publishEvent(new MyApplicationEvent("我发布了一个事件"));
    

通过结果可以发现,除了自定义的事件之外,还有一条Spring自带的事件也被打印出来,修改监听器,只打印自定义的事件:

@Component
public class MyListener implements ApplicationListener<ApplicationEvent> 
    @Override
    public void onApplicationEvent(ApplicationEvent applicationEvent) 
        if (applicationEvent instanceof MyApplicationEvent)
            System.out.println("事件:"+applicationEvent.toString());
        
    

(三)监听器源码分析:

通过 AnnotationConfigApplicationContext 进入Spring源码内部:

   public AnnotationConfigApplicationContext(Class<?>... componentClasses) 
      this();
      register(componentClasses);
      refresh();
   

这三个方法是Spring源码的核心,和监听器相关的内容在refresh方法中。进入refresh方法,和监听器相关的三个方法是initApplicationEventMulticaster()、registerListeners()和finishRefresh();

首先看initApplicationEventMulticaster()

   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);
         if (logger.isTraceEnabled()) 
            logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
         
      
      else 
         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() + "]");
         
      
   

这一段代码很好理解,首先获取ConfigurableListableBeanFactory工厂,然后判断现在Bean工厂里是否有applicationEventMulticaster,如果有的话就获取该多播器,如果没有就新建一个SimpleApplicationEventMulticaster简单多播器并注册到Bean工厂中,这段代码相当于初始化一个多播器。

接下来是registerListeners()方法:

   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);
         
      
   

上面这段注册监听器的代码一共做了三件事情,第一件事情是容器中已有的监听器注册到多播器中;第二件事情是将Bean定义中的事件,也就是我们自己定义的监听器注册到多播器中;第三件事情是发布早期待处理事件,这些早期事件我们定义的监听器是监听不了的,这里发布早期待处理事件时通过multicastEvent()方法进行发布,这个方法会和下面一起讲。

最后看finishRefresh方法,该方法调用的publishEvent方法正式将我们定义的事件发布出去。

protected void finishRefresh() 
   // Clear context-level resource caches (such as ASM metadata from scanning).
   clearResourceCaches();

   // Initialize lifecycle processor for this context.
   initLifecycleProcessor();

   // Propagate refresh to lifecycle processor first.
   getLifecycleProcessor().onRefresh();

   // Publish the final event.
   publishEvent(new ContextRefreshedEvent(this));

   // Participate in LiveBeansView MBean, if active.
   if (!NativeDetector.inNativeImage()) 
      LiveBeansView.registerApplicationContext(this);
   

进入publishEvent方法内部,可以看到它的内部同样调用了multicastEvent()方法,说明所有的真正发布动作都是由multicastEvent()完成的。

因此我们有必要来看一下multicastEvent()的发布过程,这里的代码也通俗易懂,判断是否有Executor,如果有的话异步加载invokeListener方法,没有的话同步调用invokeListener方法

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);
      
   

在invokeListener()方法中,终于看到了熟悉的onApplicationEvent方法,这个方法就是我们在自定义监听器时重写的方法,也正是在这里监听器调用了我们自己定义的onApplicationEvent(),实现了自定义的一些功能。

(四)总结

通过代码的实践以及源码的解读,监听的原理其实已经很明朗了,Spring的监听器源码可以算是观察者模式的最佳实践,我建议你照着本文的逻辑看一遍监听器源码,肯定会有新的收获。

以上是关于这次终于把Spring的监听器讲明白了的主要内容,如果未能解决你的问题,请参考以下文章

Nice!终于有人把SpringMVC讲明白了!

这次要是讲不明白 Spring Cloud 核心组件,那我就白编这故事了

终于有人把搜索引擎讲明白了

终于有人把Scrapy爬虫框架讲明白了

不服不行!终于有人把灰度发布架构设计讲明白了

终于有人把监督学习讲明白了