SpringBoot 03 事件ApplicationEvent监听处理

=PNZ=BeijingL

已于 2022-04-05 09:38:39 修改

阅读量1.2k

点赞数 2

分类专栏： Spring 文章标签： spring boot spring java

于 2022-01-20 17:51:08 首次发布

本文为CSDN博主「=PNZ=BeijingL」的原创文章，遵循 CC-BY-NC-SA 版权协议，转载请附上原文出处链接及本声明。CC-BY-NC-SA协议为创作共用-署名-非商业性-相同方式共享

本文链接：https://blog.csdn.net/Beijing_L/article/details/122587211

版权

Spring 专栏收录该内容

42 篇文章 2 订阅

订阅专栏

1.为什么使用事件

事件和直接方法调用适合于不同的情况。使用方法调用需要知道某件事A发生并调用某个方法B处理它，即知道发生什么事情然后做某件事的场景；对于事件来说我们知道发生了一个事件A，那些模块会被通知处理并不是我们关系的问题，即知道发生什么事情但不关心要做某事的场景。比如，当我们想要将某些业务处理传递给另一个线程时候，使用事件更好一些

2.Spring 自定义事件

Spring 事件/监听机制属于事件/监听器设计模式，可以视为观察者模式（Observer Pattern）的扩展, 观察者模式的Observable发布的对象是Object，因此观察者模式可以发布任何对象，而事件/监听器模式发布的内容是有类型限制的，在 Java中它必须是EventObject对象, 因此Spring 事件抽象类ApplicationEvent继承了EventObject

Spring事件机制的几个重要组件，

事件（event）可以封装和传递监听器中要处理的参数，如对象或字符串，并作为监听器中监听的目标，一般是ApplicationEvent的子类
事件发布者（publisher）事件发生的触发者。
事件广播器（Multicaster）作为实际发布事件的委托，将所有事件多播给注册的监听器，实现让监听器忽略它们不感兴趣的事件
监听器（listener）具体根据事件发生的业务处理模块，这里可以接收处理事件中封装的对象或字符串。

2.1 创建事件的方式

创建事件类MessageEvent 继承ApplicationEvent即可

public class MessageEvent extends ApplicationEvent {

    private String message;

    public MessageEvent(Object source, String message) {
        super(source);
        this.message = message;
    }

    //省略getter和setter方法
}

2.2发布事件方法

创建消息发布对象MessagePublish

通过@Autowired自动向bean中注入AnnotationConfigApplicationContext
publish方法通过ApplicationContext#publishEvent发布消息，

package com.boot.basic.event;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.stereotype.Component;

@Component
public class MessagePublish {
    
    @Autowired
    AnnotationConfigApplicationContext applicationContext;

    public void publish(String msg) {
        applicationContext.publishEvent(new MessageEvent(this,msg));
    }
}

在Spring Boot中应用上下文对象publishEvent后，事件将交给SimpleApplicationEventMulticaster处理，它是ApplicationEventMulticaster接口的实现类，该接口主要承担两种职责，一是关联ApplicationListener，二是广播ApplicationEvent

2.3.事件监听器监听并处理

方式1面向接口编程: 此方式实现ApplicationListener接口，创建MessageListener监听
方式2基于注解驱动: 使用注解 @EventListener实现Spring事件监听

创建启动类将EventConfig通过@Configuration声明为配置类，启动后发布条内容为This is a event msg的消息，用于测试上面的场景

package com.boot.basic.event;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("com.boot.basic.event")
public class EventConfig {

    public static void main(String[] args) throws InterruptedException {
        System.out.println("==========start context=============");
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(EventConfig.class);
        //容器启动后发布1条消息
        MessagePublish publish = context.getBean(MessagePublish.class);
        publish.publish("This is a event msg");

        System.out.println("==========close context=============");
    }
}

2.3.1面向接口编程

此方式实现ApplicationListener接口，创建MessageListener监听

package com.boot.basic.event;

import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;


@Component
public class MessageListener implements ApplicationListener<MessageEvent> {

    @Override
    public void onApplicationEvent(MessageEvent messageEvent) {

        String msg = messageEvent.getMessage();
        System.out.println();
        System.out.println("Message Tesing######## "+this.getClass().getName() + ":" + msg);

    }
}

监听器实现方式

1. 启动容器时从注册的Bean中找到所有ApplicationListener类型的Bean,将这些监听注册到事件广播对象中

    // AbstractApplicationContext#registerListeners部分代码
	protected void registerListeners() {
        //略掉部分代码
        //1. 通过ApplicationListener获取到实现其接口的所有BEAN
		String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
		for (String listenerBeanName : listenerBeanNames) {
            //2.将ApplicationListener监听Beans 都添加到事件广播器中
			getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
		}

	    //略掉部分代码
	}

2.，事件发布者将时间提交到广播器中，广播器循环注册的监听如果符合条件就让监听器执行事件处理

事件发布者发布事件后将时间发给SimpleApplicationEventMulticaster 对象
事件广播对象SimpleApplicationEventMulticaster先解析resource获取类型，然后从注册到自身的事件监听器集合applicationListeners中获取满足条件的监听器
每个满足监听条件的监听器执行自己的onApplicationEvent方法处理监听到的事件信息

2.3.2基于注解驱动

使用注解 @EventListener实现Spring事件监听，简化编写监听类的步骤，不需要再继承ApplicationListener接口去实现onApplicationEvent

@EventListener 注解，指定 classes，即需要处理的事件类型，一般就是 ApplicationEven 及其子类，例如@EventListener(MessageEvent.class)

package com.boot.basic.event;

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

/**
 * 基于注解驱动 使用注解 @EventListener实现Spring事件监听
 */
@Component
class EventsListener {

    @EventListener(MessageEvent.class)
    public void onEvent(MessageEvent event) {
        String msg = event.getMessage();
        System.out.println();
        System.out.println("Message Tesing######## "+this.getClass().getName() + ":" + msg);
    }
}

监听器实现方式

1. Spring容器初始化时， AbstractApplicationContext#finishBeanFactoryInitialization阶段将注解类生成一个事件ApplicationListener接口的ApplicationListenerMethodAdapter对象

2. 事件发布者将时间提交到广播器中，广播器循环注册的监听如果符合条件就让监听器执行事件处理

事件发布者发布事件后将时间发给SimpleApplicationEventMulticaster 对象
事件广播对象SimpleApplicationEventMulticaster先解析resource获取类型，然后从注册到自身的事件监听器集合applicationListeners中获取满足条件的监听器,这里获取到的是ApplicationListenerMethodAdapter对象，
ApplicationListenerMethodAdapter先解析事件参数信息，然后执行invoke，通过反射的方式执行EventListener#onEvent

2.3.3.实现异步事件

上述方式为同步处理，当多个监听器接收事件并处理时，如果先处理的监听器阻塞，那么之后的监听器都需要等其处理完后再处理

Message Tesing######## com.boot.basic.event.EventsListener:This is a event msg

Message Tesing######## com.boot.basic.event.MessageListener:This is a event msg
==========close context=============

SimpleApplicationEventMulticaster允许时间广播的时候ApplicaitonListener异步处理监听时间，其中ExecutortaskExecutor通过，源码参考如下

public class SimpleApplicationEventMulticaster extends AbstractApplicationEventMulticaster {

	@Nullable
	private Executor taskExecutor;

    //注入线程池
	public void setTaskExecutor(@Nullable Executor taskExecutor) {
		this.taskExecutor = taskExecutor;
	}

    @Override
	public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
		ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
		for (final ApplicationListener<?> listener : getApplicationListeners(event, type)) {    
            
            //这里判断如果对象注入了taskExcutor，那么就创建线程异步处理
			Executor executor = getTaskExecutor();
			if (executor != null) {
				executor.execute(() -> invokeListener(listener, event));
			}
			else {
				invokeListener(listener, event);
			}
		}
	}
    
    //略
}

可以使用 @EnableAsync开启Spring异步处理流程，默认启动流程为搜索线程池定义中的 TaskExcute实例，或一个名为 taskExcute的java.util.concurrent.Excecutor实例，如果以上都没找到，则会使用SimpleAsyncTaskExceuteor 处理异步方法调用。

参考代码

修改 EventConfig 类使用 @EnableAsync开启异步处理，并设置一个线程池

package com.boot.basic.event;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.ThreadPoolExecutor;

@EnableAsync
@Configuration
@ComponentScan("com.boot.basic.event")
public class EventConfig {

    public static void main(String[] args) throws InterruptedException {
        System.out.println("==========start context=============");
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(EventConfig.class);
        MessagePublish publish = context.getBean(MessagePublish.class);
        publish.publish("This is a event msg");

        System.out.println("==========close context=============");
        //context.close();
    }

    private static final int corePoolSize = 10;       		// 核心线程数（默认线程数）
    private static final int maxPoolSize = 100;			    // 最大线程数
    private static final int keepAliveTime = 10;			// 允许线程空闲时间（单位：默认为秒）
    private static final int queueCapacity = 200;			// 缓冲队列数
    private static final String threadNamePrefix = "Async-Service-"; // 线程池名前缀

    @Bean("taskExecutor") 
    public ThreadPoolTaskExecutor getAsyncExecutor(){
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(corePoolSize);
        executor.setMaxPoolSize(maxPoolSize);
        executor.setQueueCapacity(queueCapacity);
        executor.setKeepAliveSeconds(keepAliveTime);
        executor.setThreadNamePrefix(threadNamePrefix);
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.initialize();
        return executor;
    }
}

2. 修改监听器，增加注解@Async使监听器处理方法异步实现

package com.boot.basic.event;

import org.springframework.context.ApplicationListener;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

/**
 * 面向接口编程，实现ApplicationListener接口
 */
@Component
public class MessageListener implements ApplicationListener<MessageEvent> {

    @Async
    @Override
    public void onApplicationEvent(MessageEvent messageEvent) {
        try {
            Thread.sleep(3000L);
            String msg = messageEvent.getMessage();
            System.out.println();
            System.out.println("Message Tesing######## "+this.getClass().getName() + ":" + msg);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

重新运行EventConfig,会发现打印close contex后才执行MsssageListener#onApplicationListener 方法，云因是方法执行异步，且处理时候线程sleep等待了几秒

Message Tesing######## com.boot.basic.event.EventsListener:This is a event msg
==========close context=============

Message Tesing######## com.boot.basic.event.MessageListener:This is a event msg

3.Spring Boot 自定义事件

1. 创建时间监听

package com.boot.basic.event;

import org.springframework.context.ApplicationListener;

public class TestEventListener implements ApplicationListener<MessageEvent> {

    public void onApplicationEvent(MessageEvent messageEvent) {
        System.out.println("Message Tesing######## "+this.getClass().getName() + ":" + messageEvent.getMessage());
    }

}

2. 启动类添加创建的监听

@RestController
@SpringBootApplication
public class EventDemoApplication {

    @Autowired
    private MessagePublish messagePublish;

    public static void main(String[] args) {
        SpringApplication springApplication =
                new SpringApplication(EventDemoApplication.class);
        springApplication.addListeners(new TestEventListener());
        springApplication.run(args);
    }

    @GetMapping("/send")
    public String hello(@RequestParam(value = "msg", defaultValue = "Test message") String message) {
        messagePublish.publish(message);
        return "success";
    }

}

测试访问 http://127.0.0.1:8080/send?msg=show.me.the.money

查看控制台会发现启动添加的监听TestEventListener:show和通过组件添加的监听器都正常运行

Message Tesing######## com.boot.basic.event.EventsListener:show.me.the.money
Message Tesing######## com.boot.basic.event.TestEventListener:show.me.the.money
Message Tesing######## com.boot.basic.event.MessageListener:show.me.the.money

上面的所有代码都可以从github 找到 : 链接：GITHUB - 事件DEMO

前一篇： SpringBoot 02 配置文件

=PNZ=BeijingL

关注

2
点赞
踩
3

收藏

觉得还不错? 一键收藏
打赏
0
评论
SpringBoot 03 事件ApplicationEvent监听处理

事件（event）可以封装和传递监听器中要处理的参数，如对象或字符串，并作为监听器中监听的目标，一般是ApplicationEvent的子类事件发布者（publisher）事件发生的触发者。事件广播器（Multicaster）作为实际发布事件的委托，将所有事件多播给注册的监听器，实现让监听器忽略它们不感兴趣的事件监听器（listener）具体根据事件发生的业务处理模块，这里可以接收处理事件中封装的对象或字符串
复制链接

扫一扫