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

朱雀 2022-11-21 06:56 192阅读 0赞

### 文章目录 ###

*  Pre
 *  实现原理
 *  应用
 *   *  配置类
     *  Event事件
     *  事件监听 EventListener
     *  发布事件 publishEvent
 *  源码解析 （反推）
 *   *  Spring默认的事件广播器 SimpleApplicationEventMulticaster\#multicastEvent
     *  获取executor
     *  设置executor
     *  得出操作步骤
     *   *  方式一
         *  方式二
 *  其他开启异步的方式

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center]

--------------------

# Pre #

[Spring5源码 - 11 Spring事件监听机制\_源码篇][Spring5_ - 11 Spring]

![在这里插入图片描述][20201030203832557.gif_pic_center]

--------------------

# 实现原理 #

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

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 1]

--------------------

# 应用 #

## 配置类 ##

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

--------------------

【结果】  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 2]

如果我们把配置类中的

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

移除掉，重新运行

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 3]

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

--------------------

# 源码解析 （反推） #

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 4]

--------------------

## 获取executor ##

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 5]

SimpleApplicationEventMulticaster的一个属性  
![在这里插入图片描述][20201031003111294.png_pic_center]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 6]

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

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

--------------------

## 设置executor ##

我们知道

org.springframework.context.support.AbstractApplicationContext#refresh

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 7]

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 8]

--------------------

# 其他开启异步的方式 #

@EnbaleAsyn + @Async

![在这里插入图片描述][20201031101808982.gif_pic_center]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/081c927180554da381e9ee5720ed991b.png
[Spring5_ - 11 Spring]: https://artisan.blog.csdn.net/article/details/109371837
[20201030203832557.gif_pic_center]: /images/20221120/315f80dffcc442efa71abcee5aee6701.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221120/80baeaa9a17a41ba84080fbcce03f456.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221120/38235ce0e12944e1821548daf9dacc9a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221120/9e2f0785fd7a414fad395fb689fcbfd0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221120/87b9dc6531314a1a944f83ab8cd489c6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221120/84384ebff00b48748b8b24445e8e0a33.png
[20201031003111294.png_pic_center]: /images/20221120/1b96ff4665674e4aba6e4276d24aff51.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221120/0468283947d344da9b737b2a49237f50.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221120/4fd4bb5afe8843aeb30df0bf5a06fd6f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20221120/fd17e1a2376c49d393048f6f9672fa8c.png
[20201031101808982.gif_pic_center]: /images/20221120/16429fd5a3af4ea29d850957e854ce18.png