Spring5源码 - 12 Spring事件监听机制_异步事件监听应用及源码解析

文章目录

---

Pre

Spring5源码 - 11 Spring事件监听机制_源码篇

---

实现原理

Spring提供的事件机制，默认是同步的。如果想要使用异步事件监听，可以自己实现ApplicationEventMulticaster接口，并在Spring容器中注册id为applicationEventMulticaster的Bean ， 设置 executor 。

Spring会遍历所有的ApplicationListener， 如果 taskExecutor 不为空，这开启异步线程执行。

---

应用

配置类

package com.artisan.eventlistener2;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.event.ApplicationEventMulticaster;
import org.springframework.context.event.SimpleApplicationEventMulticaster;
import org.springframework.core.task.SimpleAsyncTaskExecutor;


@Configuration
@ComponentScan("com.artisan.eventlistener2")
public class ArtisanConfig {

  @Bean(name = "applicationEventMulticaster") // Step1: id必须叫 applicationEventMulticaster
  public ApplicationEventMulticaster multicaster(){
     // Step2:实例化SimpleApplicationEventMulticaster 
    SimpleApplicationEventMulticaster simpleApplicationEventMulticaster = new SimpleApplicationEventMulticaster();
    // Step3:设置TaskExecutor 
    simpleApplicationEventMulticaster.setTaskExecutor(new SimpleAsyncTaskExecutor());
    return simpleApplicationEventMulticaster ;
  }

}

---

Event事件

package com.artisan.eventlistener2;

import org.springframework.context.ApplicationEvent;


public class ArtisanEvent  extends ApplicationEvent {

  private String msg ;

  public ArtisanEvent(Object source) {
    super(source);
  }


  public ArtisanEvent(Object source,String msg) {
    super(source);
    this.msg = msg ;
  }

  public void print(){
    System.out.println(Thread.currentThread().getName() +  "-----" + msg);
  }

}

---

事件监听 EventListener

package com.artisan.eventlistener2;

import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;


@Component
public class ArtisanListenerByAnno   {


  @EventListener(ArtisanEvent.class)
  public void onApplicationEvent(ArtisanEvent event) {
    System.out.println(Thread.currentThread().getName() +  " EventListener  监听到ArtisanEvent.....");
    event.print();
  }
}

---

发布事件 publishEvent

package com.artisan.eventlistener2;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;


public class ArtisanTest {

  public static void main(String[] args) {
    AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(ArtisanConfig.class);
    // 模拟发布事件
    ac.publishEvent(new ArtisanEvent("xxxx","msg from artisanEvent"));
    System.out.println(Thread.currentThread().getName() + "  over");
  }
}

---

【结果】

如果我们把配置类中的

@Bean(name = "applicationEventMulticaster")
  public ApplicationEventMulticaster multicaster(){
    SimpleApplicationEventMulticaster simpleApplicationEventMulticaster = new SimpleApplicationEventMulticaster();
    simpleApplicationEventMulticaster.setTaskExecutor(new SimpleAsyncTaskExecutor());
    return simpleApplicationEventMulticaster ;
  }

移除掉，重新运行

就变成了默认的同步监听了。。。。

---

源码解析 （反推）

Spring默认的事件广播器 SimpleApplicationEventMulticaster#multicastEvent

我们分析一下 ​​ac.publishEvent(new ArtisanEvent("xxxx","msg from artisanEvent"));​​ 最终会调用到

org.springframework.context.event.SimpleApplicationEventMulticaster#multicastEvent(org.springframework.context.ApplicationEvent, org.springframework.core.ResolvableType)

---

获取executor

executor不为null则异步处理， 那看下​​executor = getTaskExecutor();​​

SimpleApplicationEventMulticaster的一个属性

那只要在实例化SimpleApplicationEventMulticaster的时候 set属性值就可以了哇。

所以现在的问题是什么时候给线程池属性赋值的问题？

---

设置executor

我们知道

org.springframework.context.support.AbstractApplicationContext#refresh

看看 initApplicationEventMulticaster

protected void initApplicationEventMulticaster() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    //判断IOC容器中包含applicationEventMulticaster 事件多播器的Bean的name
    if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
        //创建一个applicationEventMulticaster的bean放在IOC 容器中,bean的name 为applicationEventMulticaster
      this.applicationEventMulticaster =beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
      if (logger.isDebugEnabled()) {
        logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
      }
    }
    
    else { //容器中不包含一个beanName 为applicationEventMulticaster的多播器组件
        //创建一个SimpleApplicationEventMulticaster 多播器
      this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
      //注册到容器中
      beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
      if (logger.isDebugEnabled()) {
        logger.debug("Unable to locate ApplicationEventMulticaster with name '" +
            APPLICATION_EVENT_MULTICASTER_BEAN_NAME +
            "': using default [" + this.applicationEventMulticaster + "]");
      }
    }
  }

通过源码我们知道，Spring会先从容器中找 bean name 为 “applicationEventMulticaster” 的 bean，so问题就简单了，我们只要自定义个 bean name 为 ​​applicationEventMulticaster​​ 的 bean，并给其属性 taskExecutor 赋上自定义的线程池即可，这个时候就能实现异步事件处理了 .

得出操作步骤

所以，可以这么配置

方式一

@Configuration
@ComponentScan("com.artisan.eventlistener2")
public class ArtisanConfig {

  @Bean(name = "applicationEventMulticaster")
  public ApplicationEventMulticaster multicaster(){
    SimpleApplicationEventMulticaster simpleApplicationEventMulticaster = new SimpleApplicationEventMulticaster();
    simpleApplicationEventMulticaster.setTaskExecutor(new SimpleAsyncTaskExecutor());
    return simpleApplicationEventMulticaster ;
  }

}

方式二

或者写一个类实现 AbstractApplicationEventMulticaster ，仿照 SimpleApplicationEventMulticaster 即可

package com.artisan.eventlistener2;

import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.AbstractApplicationEventMulticaster;
import org.springframework.core.ResolvableType;
import org.springframework.core.task.SimpleAsyncTaskExecutor;
import org.springframework.core.task.TaskExecutor;
import org.springframework.stereotype.Component;

import java.util.Iterator;

@Component("applicationEventMulticaster")
public class AsyncApplicationEventMulticaster extends AbstractApplicationEventMulticaster {

  private TaskExecutor taskExecutor = new SimpleAsyncTaskExecutor();

  public void setTaskExecutor(TaskExecutor taskExecutor) {
    this.taskExecutor = (taskExecutor != null ? taskExecutor : new SimpleAsyncTaskExecutor());
  }

  protected TaskExecutor getTaskExecutor() {
    return this.taskExecutor;
  }

  @Override
  @SuppressWarnings("unchecked")
  public void multicastEvent(final ApplicationEvent event) {

  }

  @Override
  public void multicastEvent(ApplicationEvent event, ResolvableType eventType) {
    for (Iterator<ApplicationListener<?>> it = getApplicationListeners().iterator(); it.hasNext();) {
      final ApplicationListener listener =  it.next();
      System.out.println("-----------自定义异步事件监听-----------");
      getTaskExecutor().execute(() -> listener.onApplicationEvent(event));
    }
  }
}

---

其他开启异步的方式

@EnbaleAsyn + @Async