详解Spring事件发布与监听机制

一、ApplicationContext 事件机制

ApplicationContext 事件机制采用观察者设计模式来实现，通过 ApplicationEvent 事件类和 ApplicationListener 监听器接口，可以实现 ApplicationContext 事件发布与处理。

每当 ApplicationContext 发布 ApplicationEvent 时，如果 Spring 容器中有 ApplicationListener bean，则监听器会被触发执行相应的处理。当然，ApplicationEvent 事件的发布需要显示触发，要么 Spring 显示触发，要么我们显示触发。

二、ApplicationListener 监听器

定义应用监听器需要实现的接口。此接口继承了 JDK 标准的事件监听器接口 EventListener，EventListener 接口是一个空的标记接口，推荐所有事件监听器必须要继承它。

1. package org.springframework.context;
2.  
3. import java.util.EventListener;
4.  
5. @FunctionalInterface
6. public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {
7.  
8. /**
9. * 处理应用事件
10. */
11. void onApplicationEvent(E event);
12. }

1. package java.util;
2.  
3. public interface EventListener {
4. }

ApplicationListener 是个泛型接口，我们自定义此接口的实现类时，如果指定了泛型的具体事件类，那么只会监听此事件。如果不指定具体的泛型，则会监听 ApplicationEvent 抽象类的所有子类事件。

如下我们定义一个监听器，监听具体的事件，例如监听 ApplicationStartedEvent 事件。

1. package com.chenpi;
2.  
3. import lombok.extern.slf4j.Slf4j;
4. import org.springframework.boot.context.event.ApplicationStartedEvent;
5. import org.springframework.context.ApplicationListener;
6. import org.springframework.stereotype.Component;
7.  
8. @Slf4j
9. @Component
10. public class MyApplicationListener implements ApplicationListener<ApplicationStartedEvent> {
11. @Override
12. public void onApplicationEvent(ApplicationStartedEvent event) {
13. log.info(">>> MyApplicationListener：{}", event);
14. }
15. }

启动服务，会发现在服务启动后，此监听器被触发了。

如果不指定具体的泛型类，则会监听 ApplicationEvent 抽象类的所有子类事件。如下所示：

1. package com.chenpi;
2.  
3. import lombok.extern.slf4j.Slf4j;
4. import org.springframework.context.ApplicationEvent;
5. import org.springframework.context.ApplicationListener;
6. import org.springframework.stereotype.Component;
7.  
8. @Slf4j
9. @Component
10. public class MyApplicationListener implements ApplicationListener {
11. @Override
12. public void onApplicationEvent(ApplicationEvent event) {
13. log.info(">>> MyApplicationListener：{}", event);
14. }
15. }

注意，监听器类的 bean 要注入到 Spring 容器中，不然不会生效。一种是使用注解注入，例如 @Component。另外可以使用 SpringApplicationBuilder.listeners() 方法添加，不过这两种方式有区别的，看以下示例。

首先我们使用 @Component 注解方式，服务启动时，监视到了2个事件：

• ApplicationStartedEvent
• ApplicationReadyEvent

1. package com.chenpi;
2.  
3. import lombok.extern.slf4j.Slf4j;
4. import org.springframework.boot.context.event.SpringApplicationEvent;
5. import org.springframework.context.ApplicationListener;
6. import org.springframework.stereotype.Component;
7.  
8. @Slf4j
9. @Component
10. public class MyApplicationListener implements ApplicationListener<SpringApplicationEvent> {
11. @Override
12. public void onApplicationEvent(SpringApplicationEvent event) {
13. log.info(">>> MyApplicationListener：{}", event);
14. }
15. }

而使用 SpringApplicationBuilder.listeners() 方法添加监听器，服务启动时，监听到了5个事件：

• ApplicationEnvironmentPreparedEvent
• ApplicationContextInitializedEvent
• ApplicationPreparedEvent
• ApplicationStartedEvent
• ApplicationReadyEvent

1. package com.chenpi;
2.  
3. import org.springframework.boot.SpringApplication;
4. import org.springframework.boot.autoconfigure.SpringBootApplication;
5. import org.springframework.boot.builder.SpringApplicationBuilder;
6. import org.springframework.context.ConfigurableApplicationContext;
7.  
8. @SpringBootApplication
9. public class Application {
10.  
11. public static void main(String[] args) {
12. // SpringApplication.run(Application.class, args);
13.  
14. SpringApplication app = new SpringApplicationBuilder(Application.class)
15. .listeners(new MyApplicationListener()).build();
16. app.run(args);
17. }
18. }

其实这是和监听器 bean 注册的时机有关，@component 注解的监听器 bean 只有在 bean 初始化注册完后才能使用；而通过 SpringApplicationBuilder.listeners() 添加的监听器 bean 是在容器启动前，所以监听到的事件比较多。但是注意，这两个不要同时使用，不然监听器会重复执行两遍。

如果你想在监听器 bean 中注入其他 bean（例如 @Autowired），那最好是使用注解形式，因为如果太早发布监听器，可能其他 bean 还未初始化完成，可能会报错。

三、ApplicationEvent 事件

ApplicationEvent 是所有应用事件需要继承的抽象类。它继承了 EventObject 类，EventObject 是所有事件的根类，这个类有个 Object 类型的对象 source，代表事件源。所有继承它的类的构造函数都必须要显示传递这个事件源。

1. package org.springframework.context;
2.  
3. import java.util.EventObject;
4.  
5. public abstract class ApplicationEvent extends EventObject {
6.  
7. private static final long serialVersionUID = 7099057708183571937L;
8.  
9. // 发布事件的系统时间
10. private final long timestamp;
11.  
12. public ApplicationEvent(Object source) {
13. super(source);
14. this.timestamp = System.currentTimeMillis();
15. }
16.  
17. public final long getTimestamp() {
18. return this.timestamp;
19. }
20. }

1. package java.util;
2.  
3. public class EventObject implements java.io.Serializable {
4.  
5. private static final long serialVersionUID = 5516075349620653480L;
6.  
7. protected transient Object source;
8.  
9. public EventObject(Object source) {
10. if (source == null)
11. throw new IllegalArgumentException("null source");
12.  
13. this.source = source;
14. }
15.  
16. public Object getSource() {
17. return source;
18. }
19.  
20. public String toString() {
21. return getClass().getName() + "[source=" + source + "]";
22. }
23. }

在 Spring 中，比较重要的事件类是 SpringApplicationEvent。Spring 有一些内置的事件，当完成某种操作时会触发某些事件。这些内置事件继承 SpringApplicationEvent 抽象类。SpringApplicationEvent 继承 ApplicationEvent 并增加了字符串数组参数字段 args。

1. @SuppressWarnings("serial")
2. public abstract class SpringApplicationEvent extends ApplicationEvent {
3.  
4. private final String[] args;
5.  
6. public SpringApplicationEvent(SpringApplication application, String[] args) {
7. super(application);
8. this.args = args;
9. }
10.  
11. public SpringApplication getSpringApplication() {
12. return (SpringApplication) getSource();
13. }
14.  
15. public final String[] getArgs() {
16. return this.args;
17. }
18. }

我们可以编写自己的监听器，然后监听这些事件，实现自己的业务逻辑。例如编写 ApplicationListener 接口的实现类，监听 ContextStartedEvent 事件，当应用容器 ApplicationContext 启动时，会发布该事件，所以我们编写的监听器会被触发。

• ContextRefreshedEvent：ApplicationContext 被初始化或刷新时，事件被发布。ConfigurableApplicationContext接口中的 refresh() 方法被调用也会触发事件发布。初始化是指所有的 Bean 被成功装载，后处理 Bean 被检测并激活，所有单例 Bean 被预实例化，ApplicationContext 容器已就绪可用。
• ContextStartedEvent：应用程序上下文被刷新后，但在任何 ApplicationRunner 和 CommandLineRunner 被调用之前，发布此事件。
• ApplicationReadyEvent：此事件会尽可能晚地被发布，以表明应用程序已准备好为请求提供服务。事件源是SpringApplication 本身，但是要注意修改它的内部状态，因为到那时所有初始化步骤都已经完成了。
• ContextStoppedEvent：ConfigurableApplicationContext 接口的 stop() 被调用停止 ApplicationContext 时，事件被发布。
• ContextClosedEvent：ConfigurableApplicationContext 接口的 close() 被调用关闭 ApplicationContext 时，事件被发布。注意，一个已关闭的上下文到达生命周期末端后，它不能被刷新或重启。
• ApplicationFailedEvent：当应用启动失败后发布事件。
• ApplicationEnvironmentPreparedEvent：事件是在 SpringApplication 启动时发布的，并且首次检查和修改 Environment 时，此时上 ApplicationContext 还没有创建。
• ApplicationPreparedEvent：事件发布时，SpringApplication 正在启动，ApplicationContext 已经完全准备好，但没有刷新。在这个阶段，将加载 bean definitions 并准备使用 Environment。
• RequestHandledEvent：这是一个 web 事件，只能应用于使用 DispatcherServlet 的 Web 应用。在使用 Spring 作为前端的 MVC 控制器时，当 Spring 处理用户请求结束后，系统会自动触发该事件。

四、自定义事件和监听器

前面介绍了自定义监听器，然后监听 Spring 原有的事件。下面介绍自定义事件和自定义监听器，然后在程序中发布事件，触发监听器执行，实现自己的业务逻辑。

首先自定义事件，继承 ApplicationEvent，当然事件可以自定义自己的属性。

1. package com.chenpi;
2.  
3. import lombok.Getter;
4. import lombok.Setter;
5. import lombok.ToString;
6. import org.springframework.context.ApplicationEvent;
7.  
8. @Getter
9. @Setter
10. public class MyApplicationEvent extends ApplicationEvent {
11.  
12. // 事件可以增加自己的属性
13. private String myField;
14.  
15. public MyApplicationEvent(Object source, String myField) {
16. // 绑定事件源
17. super(source);
18. this.myField = myField;
19. }
20.  
21. @Override
22. public String toString() {
23. return "MyApplicationEvent{" + "myField='" + myField + '\'' + ", source=" + source + '}';
24. }
25. }

然后自定义监听器，监听我们自定义的事件。

1. package com.chenpi;
2.  
3. import lombok.extern.slf4j.Slf4j;
4. import org.springframework.context.ApplicationListener;
5.  
6. @Slf4j
7. public class MyApplicationListener implements ApplicationListener<MyApplicationEvent> {
8. @Override
9. public void onApplicationEvent(MyApplicationEvent event) {
10. log.info(">>> MyApplicationListener：{}", event);
11. }
12. }

注册监听器和发布事件。注册监听器上面讲解了有两种方式。事件的发布可以通过 ApplicationEventPublisher.publishEvent() 方法。此处演示直接用 configurableApplicationContext 发布，它实现了 ApplicationEventPublisher 接口。

1. package com.chenpi;
2.  
3. import org.springframework.boot.SpringApplication;
4. import org.springframework.boot.autoconfigure.SpringBootApplication;
5. import org.springframework.boot.builder.SpringApplicationBuilder;
6. import org.springframework.context.ConfigurableApplicationContext;
7.  
8. @SpringBootApplication
9. public class Application {
10.  
11. public static void main(String[] args) {
12. // SpringApplication.run(Application.class, args);
13. // 注册监听器
14. SpringApplication app = new SpringApplicationBuilder(Application.class)
15. .listeners(new MyApplicationListener()).build();
16. ConfigurableApplicationContext configurableApplicationContext = app.run(args);
17. // 方便演示，在项目启动后发布事件，当然也可以在其他操作和其他时间点发布事件
18. configurableApplicationContext
19. .publishEvent(new MyApplicationEvent("我是事件源，项目启动成功后发布事件", "我是自定义事件属性"));
20. }
21. }

启动服务，结果显示确实监听到发布的事件了。

2021-06-26 16:15:09.584  INFO 10992 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8081 (http) with context path ''

2021-06-26 16:15:09.601  INFO 10992 --- [           main] com.chenpi.Application                   : Started Application in 2.563 seconds (JVM running for 4.012)

2021-06-26 16:15:09.606  INFO 10992 --- [           main] com.chenpi.MyApplicationListener         : >>> MyApplicationListener：MyApplicationEvent{myField='我是自定义事件属性', source=我是事件源，项目启动成功后发布事件}

事件监听机制能达到分发，解耦效果。例如可以在业务类中发布事件，让监听在此事件的监听器执行自己的业务处理。例如：

1. package com.chenpi;
2.  
3. import org.springframework.context.ApplicationEventPublisher;
4. import org.springframework.context.ApplicationEventPublisherAware;
5. import org.springframework.stereotype.Service;
6.  
7. @Service
8. public class MyService implements ApplicationEventPublisherAware {
9.  
10. private ApplicationEventPublisher applicationEventPublisher;
11.  
12. @Override
13. public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
14. this.applicationEventPublisher = applicationEventPublisher;
15. }
16.  
17. public void testEvent() {
18. applicationEventPublisher
19. .publishEvent(new MyApplicationEvent("我是事件源", "我是自定义事件属性"));
20. }
21. }

五、注解式监听器

除了实现 ApplicationListener 接口创建监听器外，Spring 还提供了注解 @EventListener 来创建监听器。

1. package com.chenpi;
2.  
3. import org.springframework.context.event.EventListener;
4. import org.springframework.stereotype.Component;
5.  
6. import lombok.extern.slf4j.Slf4j;
7.  
8. @Slf4j
9. @Component
10. public class MyApplicationListener01 {
11. @EventListener
12. public void onApplicationEvent(MyApplicationEvent event) {
13. log.info(">>> MyApplicationListener：{}", event);
14. }
15. }

而且注解还可以通过条件过滤只监听指定条件的事件。例如事件的 myField 属性的值等于"陈皮"的事件。

1. package com.chenpi;
2.  
3. import org.springframework.context.event.EventListener;
4. import org.springframework.stereotype.Component;
5.  
6. import lombok.extern.slf4j.Slf4j;
7.  
8. @Slf4j
9. @Component
10. public class MyApplicationListener01 {
11. @EventListener(condition = "#event.myField.equals('陈皮')")
12. public void onApplicationEvent(MyApplicationEvent event) {
13. log.info(">>> MyApplicationListener：{}", event);
14. }
15. }

还可以在同一个类中定义多个监听，对同一个事件的不同监听还可以指定顺序。order 值越小越先执行。

1. package com.chenpi;
2.  
3. import org.springframework.context.event.EventListener;
4. import org.springframework.core.annotation.Order;
5. import org.springframework.stereotype.Component;
6.  
7. import lombok.extern.slf4j.Slf4j;
8.  
9. @Slf4j
10. @Component
11. public class MyApplicationListener01 {
12. @Order(2)
13. @EventListener
14. public void onApplicationEvent(MyApplicationEvent event) {
15. log.info(">>> onApplicationEvent order=2：{}", event);
16. }
17.  
18. @Order(1)
19. @EventListener
20. public void onApplicationEvent01(MyApplicationEvent event) {
21. log.info(">>> onApplicationEvent order=1：{}", event);
22. }
23.  
24. @EventListener
25. public void otherEvent(YourApplicationEvent event) {
26. log.info(">>> otherEvent：{}", event);
27. }
28. }

执行结果如下：

>>> onApplicationEvent order=1：MyApplicationEvent{myField='陈皮', source=我是事件源}

>>> onApplicationEvent order=2：MyApplicationEvent{myField='陈皮', source=我是事件源}

>>> otherEvent：MyApplicationEvent{myField='我是自定义事件属性01', source=我是事件源01}

事件的监听处理是同步的，如下：

1. package com.chenpi;
2.  
3. import lombok.extern.slf4j.Slf4j;
4. import org.springframework.context.ApplicationEventPublisher;
5. import org.springframework.context.ApplicationEventPublisherAware;
6. import org.springframework.stereotype.Service;
7.  
8. @Service
9. @Slf4j
10. public class MyService implements ApplicationEventPublisherAware {
11.  
12. private ApplicationEventPublisher applicationEventPublisher;
13.  
14. @Override
15. public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
16. this.applicationEventPublisher = applicationEventPublisher;
17. }
18.  
19. public void testEvent() {
20. log.info(">>> testEvent begin");
21. applicationEventPublisher.publishEvent(new MyApplicationEvent("我是事件源", "陈皮"));
22. applicationEventPublisher.publishEvent(new YourApplicationEvent("我是事件源01", "我是自定义事件属性01"));
23. log.info(">>> testEvent end");
24. }
25. }

执行结果如下：

2021-06-26 20:34:27.990  INFO 12936 --- [nio-8081-exec-1] com.chenpi.MyService                     : >>> testEvent begin

2021-06-26 20:34:27.990  INFO 12936 --- [nio-8081-exec-1] com.chenpi.MyApplicationListener01       : >>> onApplicationEvent order=1：MyApplicationEvent{myField='陈皮', source=我是事件源}

2021-06-26 20:34:27.991  INFO 12936 --- [nio-8081-exec-1] com.chenpi.MyApplicationListener01       : >>> onApplicationEvent order=2：MyApplicationEvent{myField='陈皮', source=我是事件源}

2021-06-26 20:34:27.992  INFO 12936 --- [nio-8081-exec-1] com.chenpi.MyApplicationListener01       : >>> otherEvent：MyApplicationEvent{myField='我是自定义事件属性01', source=我是事件源01}

2021-06-26 20:34:27.992  INFO 12936 --- [nio-8081-exec-1] com.chenpi.MyService                     : >>> testEvent end

不过，我们也可以显示指定异步方式去执行监听器，记得在服务添加 @EnableAsync 注解开启异步注解。

1. package com.chenpi;
2.  
3. import org.springframework.context.event.EventListener;
4. import org.springframework.core.annotation.Order;
5. import org.springframework.scheduling.annotation.Async;
6. import org.springframework.stereotype.Component;
7.  
8. import lombok.extern.slf4j.Slf4j;
9.  
10. @Slf4j
11. @Component
12. public class MyApplicationListener01 {
13.  
14. @Async
15. @Order(2)
16. @EventListener
17. public void onApplicationEvent(MyApplicationEvent event) {
18. log.info(">>> onApplicationEvent order=2：{}", event);
19. }
20.  
21. @Order(1)
22. @EventListener
23. public void onApplicationEvent01(MyApplicationEvent event) {
24. log.info(">>> onApplicationEvent order=1：{}", event);
25. }
26.  
27. @Async
28. @EventListener
29. public void otherEvent(YourApplicationEvent event) {
30. log.info(">>> otherEvent：{}", event);
31. }
32. }

执行结果如下，注意打印的线程名。

2021-06-26 20:37:04.807  INFO 9092 --- [nio-8081-exec-1] com.chenpi.MyService                     : >>> testEvent begin

2021-06-26 20:37:04.819  INFO 9092 --- [nio-8081-exec-1] com.chenpi.MyApplicationListener01       : >>> onApplicationEvent order=1：MyApplicationEvent{myField='陈皮', source=我是事件源}

2021-06-26 20:37:04.831  INFO 9092 --- [         task-1] com.chenpi.MyApplicationListener01       : >>> onApplicationEvent order=2：MyApplicationEvent{myField='陈皮', source=我是事件源}

2021-06-26 20:37:04.831  INFO 9092 --- [nio-8081-exec-1] com.chenpi.MyService                     : >>> testEvent end

2021-06-26 20:37:04.831  INFO 9092 --- [         task-2] com.chenpi.MyApplicationListener01       : >>> otherEvent：MyApplicationEvent{myField='我是自定义事件属性01', source=我是事件源01}

以上就是详解Spring事件发布与监听机制的详细内容，更多关于Spring事件发布与监听机制的资料请关注服务器之家其它相关文章！

原文链接：https://www.cnblogs.com/luciochn/p/14940123.html