SpringBoot 使用 ApplicationEvent

最新推荐文章于 2024-05-10 11:45:29 发布
最新推荐文章于 2024-05-10 11:45:29 发布
阅读量811 收藏 1
点赞数 2
文章标签： java 开发语言
原文链接：http://www.moguit.cn/info/1248
版权

目录

简介

事件监听简述

实例

同步监听(无序)

同步监听(有序)

异步监听(无序)

简介

说明

本文用示例介绍SpringBoot中的事件的用法及原理。

事件监听简述

事件的发布与监听从属于观察者模式；和MQ相比，事件的发布与监听偏向于处理服务内的某些逻辑。 

多个监听器可以监听同一个事件。例如：发布了事件A，监听器A和监听器B都监听了事件A，则监听器A和B都会进行处理。

同步与异步监听

监听方式特点使用时机
同步监听发布器线程与监听器线程处于同一线程1.监听逻辑处理较快
2.需要紧接着根据监听器追踪业务线程
异步监听发布器线程与监听器线程处于不同线程1.监听逻辑处理比较耗时
2.追求响应性能

事件的顺序

可使用实现Ordered接口的方式，调整监听器顺序。

注意：必须是同时实现 ApplicationListener<MyEvent>,Ordered这样的方法才能控制顺序。

下边几种都是无法控制顺序的：

  • @Component+@EventListerner+实现Ordered
  • 实现 ApplicationListener<MyEvent>+@Order

实例

同步监听(无序)

package com.example.event;
 
import org.springframework.context.ApplicationEvent;
 
public class MyEvent extends ApplicationEvent {
 
    public MyEvent(Object source) {
        super(source);
    }
 
}

监听器

监听器1

package com.example.event;
 
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;
 
@Component
public class MyListener {
    @EventListener
    public void abc(MyEvent event) {
        System.out.println("监听器：        " + "MyListener");
        System.out.println("监听器所在线程：" + Thread.currentThread().getName());
        System.out.println("事件：          " + event);
        System.out.println("事件的数据：    " + event.getSource());
    }
}

监听器2

package com.example.event;
 
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;
 
@Component
public class MyListener2 {
 
    @EventListener
    public void onApplicationEvent(MyEvent event) {
        System.out.println("监听器：      " + "MyListener2");
        System.out.println("  所在线程：  " + Thread.currentThread().getName());
        System.out.println("  事件：      " + event);
        System.out.println("  事件的数据：" + event.getSource());
    }
}

发布器

package com.example.event;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Component;
 
@Component
public class MyPublisher {
    @Autowired
    ApplicationContext applicationContext;
 
    public void myPublish(String message) {
        System.out.println("发布器所在线程：" + Thread.currentThread().getName());
        applicationContext.publishEvent(new MyEvent(message));
    }
}

测试

写一个Controller

package com.example.controller;
 
import com.example.event.MyPublisher;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
public class HelloController {
    @Autowired
    MyPublisher myPublisher;
 
    @GetMapping("/test1")
    public String test1() {
        myPublisher.myPublish("Hello");
        return "test1 success";
    }
}

启动后，访问：http://localhost:8080/test1

后端输出：

发布器所在线程：http-nio-8080-exec-1
监听器：      MyListener
  所在线程：  http-nio-8080-exec-1
  事件：      com.example.event.MyEvent[source=Hello]
  事件的数据：Hello
监听器：      MyListener2
  所在线程：  http-nio-8080-exec-1
  事件：      com.example.event.MyEvent[source=Hello]
  事件的数据：Hello

可以发现，所有监听器和发布器都在同一个线程

同步监听(有序)

事件

package com.example.event;
 
import org.springframework.context.ApplicationEvent;
 
public class MyEvent extends ApplicationEvent {
 
    public MyEvent(Object source) {
        super(source);
    }
 
}

监听器

监听器1

package com.example.event;
 
import org.springframework.context.ApplicationListener;
import org.springframework.core.Ordered;
import org.springframework.stereotype.Component;
 
@Component
public class MyListener implements ApplicationListener<MyEvent>,  Ordered {
    @Override
    public void onApplicationEvent(MyEvent event) {
        System.out.println("监听器：      " + "MyListener");
        System.out.println("  所在线程：  " + Thread.currentThread().getName());
        System.out.println("  事件：      " + event);
        System.out.println("  事件的数据：" + event.getSource());
    }
 
    @Override
    public int getOrder() {
        return 2;
    }
}

监听器2

package com.example.event;
 
import org.springframework.context.ApplicationListener;
import org.springframework.core.Ordered;
import org.springframework.stereotype.Component;
 
@Component
public class MyListener2 implements ApplicationListener<MyEvent>, Ordered {
 
    public void onApplicationEvent(MyEvent event) {
        System.out.println("监听器：      " + "MyListener2");
        System.out.println("  所在线程：  " + Thread.currentThread().getName());
        System.out.println("  事件：      " + event);
        System.out.println("  事件的数据：" + event.getSource());
    }
 
    @Override
    public int getOrder() {
        return 1;
    }
}

发布器

package com.example.event;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Component;
 
@Component
public class MyPublisher {
    @Autowired
    ApplicationContext applicationContext;
 
    public void myPublish(String message) {
        System.out.println("发布器所在线程：" + Thread.currentThread().getName());
        applicationContext.publishEvent(new MyEvent(message));
    }
}

测试

写一个Controller

package com.example.controller;
 
import com.example.event.MyPublisher;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
public class HelloController {
    @Autowired
    MyPublisher myPublisher;
 
    @GetMapping("/test1")
    public String test1() {
        myPublisher.myPublish("Hello");
        return "test1 success";
    }
}

启动后，访问：http://localhost:8080/test1

后端输出：

发布器所在线程：http-nio-8080-exec-1
监听器：      MyListener2
  所在线程：  http-nio-8080-exec-1
  事件：      com.example.event.MyEvent[source=Hello]
  事件的数据：Hello
监听器：      MyListener
  所在线程：  http-nio-8080-exec-1
  事件：      com.example.event.MyEvent[source=Hello]
  事件的数据：Hello

如果将监听器的实现的Ordered顺序颠倒，则输出结果如下：

发布器所在线程：http-nio-8080-exec-1
监听器：      MyListener
  所在线程：  http-nio-8080-exec-1
  事件：      com.example.event.MyEvent[source=Hello]
  事件的数据：Hello
监听器：      MyListener2
  所在线程：  http-nio-8080-exec-1
  事件：      com.example.event.MyEvent[source=Hello]
  事件的数据：Hello

异步监听(无序)

开启异步配置，配置线程池

@Configuration
// 开启spring异步
@EnableAsync  
public class BaseConfig {

    @Bean("XXXXExecutor")
    public ThreadPoolTaskExecutor XXXXExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(50);
        executor.setMaxPoolSize(100);
        executor.setQueueCapacity(500);
        executor.setKeepAliveSeconds(60);
        executor.setThreadNamePrefix("XXXXExecutor-");
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.initialize();
        return executor;
    }

}

方法：

  • 开启异步监听
  • 在监听器上加@Async（此监听器必须是@Component方法注册的）

事件

package com.example.event;
 
import org.springframework.context.ApplicationEvent;
 
public class MyEvent extends ApplicationEvent {
 
    public MyEvent(Object source) {
        super(source);
    }
 
}

同步监听器

package com.example.event;
 
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;
 
@Component
public class MyListener {
    @EventListener
    public void abc(MyEvent event) {
        System.out.println("监听器：      " + "MyListener");
        System.out.println("  所在线程：  " + Thread.currentThread().getName());
        System.out.println("  事件：      " + event);
        System.out.println("  事件的数据：" + event.getSource());
    }
}

异步监听器

package com.example.event;
 
import org.springframework.context.event.EventListener;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;
 
@Component
// 采用默认线程池
//@Async
//采用配置好的XXXXExecutor线程池
@Async("XXXXExecutor")
public class MyListener2 {
 
    @EventListener
    public void onApplicationEvent(MyEvent event) {
        System.out.println("监听器：      " + "MyListener2");
        System.out.println("  所在线程：  " + Thread.currentThread().getName());
        System.out.println("  事件：      " + event);
        System.out.println("  事件的数据：" + event.getSource());
    }
}

发布器

package com.example.event;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Component;
 
@Component
public class MyPublisher {
    @Autowired
    ApplicationContext applicationContext;
 
    public void myPublish(String message) {
        System.out.println("发布器所在线程：" + Thread.currentThread().getName());
        applicationContext.publishEvent(new MyEvent(message));
    }
}

启动类

package com.example;
 
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync;
 
@SpringBootApplication
@EnableAsync
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

测试

写一个Controller

package com.example.controller;
 
import com.example.event.MyPublisher;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
public class HelloController {
    @Autowired
    MyPublisher myPublisher;
 
    @GetMapping("/test1")
    public String test1() {
        myPublisher.myPublish("Hello");
        return "test1 success";
    }
}

启动后，访问：http://localhost:8080/test1

后端输出：

发布器所在线程：http-nio-8080-exec-1
监听器：      MyListener
  所在线程：  http-nio-8080-exec-1
  事件：      com.example.event.MyEvent[source=Hello]
  事件的数据：Hello
监听器：      MyListener2
  所在线程：  task-1
  事件：      com.example.event.MyEvent[source=Hello]
  事件的数据：Hello

javacTree
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【Spring】Spring Boot 之事件（Event）ApplicationEvent
九师兄
01-02 1761
ApplicationContext 通过 ApplicationEvent 类和 ApplicationListener 接口进行事件处理。如果将实现 ApplicationListener 接口的 bean 注入到上下文中，则每次使用 ApplicationContext 发布 ApplicationEvent 时，都会通知该 bean。本质上，这是标准的观察者设计模式。
springboot07
12-14
在SpringBoot中，我们可以利用ApplicationEvent和ApplicationListener进行事件驱动编程。发布一个事件（ApplicationEvent），然后注册监听器（ApplicationListener）来响应这个事件，这为系统间的解耦提供了便利。 ...
SpringBoot教程(十七) | SpringBoot中ApplicationEvent用法
weixin_42907150的博客
01-16 636
对不起大家，昨天文章里的告别说早了，这个系列还不能就这么结束。我们前面的文章中讲解过RabbitMQ的用法，所谓MQ就是一种发布订阅模式的消息模型。在Spring中其实本身也为我们提供了一种发布订阅模式的事件处理方式，就是ApplicationEvent和 ApplicationListener，这是一种基于观察者模式实现事件监听功能。也已帮助我们完成业务逻辑的解耦，提高程序的扩展性和可维护性。
Spring事件(Application Event)
最新发布
BUG指挥课堂
05-10 85
因为它是@EventListener，且MyListener这个Bean是交给SpringBoot容器管理的，而feign子容器创建的时候，其实还处于Boot容器流程的内部，所以此时@EventListener肯定是没有注册上的，因此此方法代表的监听器就不会生效了。这就是我们getApplicationListeners的具体内容，我们发现：它只会拿注册到本容器的监听器（注册在谁身上就是谁的~~~），并不会去父类的拿的，所以这点一定要注意，你自己写监听器的时候也是需要注意这一点的，避免一些重复执行吧~~~
第二十七章：SpringBoot使用ApplicationEvent&Listener完成业务解耦
恒宇少年De成长之路
07-21 956
ApplicationEvent以及Listener是Spring为我们提供的一个事件监听、订阅的实现，内部实现原理是观察者设计模式，设计初衷也是为了系统业务逻辑之间的解耦，提高可扩展性以及可维护性。事件发布者并不需要考虑谁去监听，监听具体的实现内容是什么，发布者的工作只是为了发布事件而已。 我们平时日常生活中也是经常会有这种情况存在，如：我们在平时拔河比赛中，裁判员给我们吹响了...
基于Spring Boot应用ApplicationEvent
zhangbeizhen18的博客
06-18 739
记录：276 场景：利用Spring的机制发布ApplicationEvent和监听ApplicationEvent。 版本：Spring Boot 2.6.3
Spring Boot框架强大的事件驱动模型(ApplicationEvent)
勤于笔记，成于点滴。
04-25 1234
SpringBoot框架提供了强大的事件驱动模型(ApplicationEvent)，允许应用程序组件之间通过发布和监听事件来进行松耦合的通信。在实际的生产场景中，我们可以使用事件进行缓存、邮件、日志解耦，从而提高系统性能。
详解SpringBoot 发布ApplicationEventPublisher和监听ApplicationEvent事件
08-25
在Spring Boot应用中，`ApplicationEventPublisher`和`ApplicationEvent`是Spring框架提供的一种轻量级事件驱动模型，用于在应用程序内部实现松耦合的通信。这种机制允许一个组件在执行某些操作后通知其他组件，而...
springboot 业务插件demo
03-16
6. **事件驱动**：利用Spring的ApplicationEvent和ApplicationListener机制，当插件被加载或卸载时，可以发布和监听相应的事件，以执行必要的操作，如刷新缓存、更新数据库映射等。 在"beandymanicload"这个压缩包...
springboot.zip
05-07
在SpringBoot中，`ApplicationEventPublisher` 和 `ApplicationEvent` 是两个关键组件，用于实现事件驱动的编程模式。 `ApplicationEvent` 是Spring框架中的一个接口，它是事件的核心代表。当应用中发生某个重要...
SpringBoot监听器
05-28
public class CustomEvent extends ApplicationEvent { public CustomEvent(Object source) { super(source); } } // 监听自定义事件的类 @Component public class CustomEventListener implements Application...
【Spring Boot】Spring基础 —— 事件（Application Event）
酱懵静的博客
04-06 580
事件（Application Event） 文章目录1.概论2.新建包3.自定义事件4.定义事件监听器5.定义事件发布类6.定义配置类7.定义测试主类8.测试 1.概论 Spring的事件（Application Event）为Bean与Bean之间的消息通信提供了支持。当一个Bean处理完一个任务之后，希望另外一个Bean知道并能做相应的处理，这时我们就需要让另外一个Bean监听当前...
SpringBoot -- 事件（Application Event）
yygr的博客
05-26 724
https://www.cnblogs.com/gdwkong/p/9309459.html 　　Spring的事件为Bean与Bean之间的消息通信提供了支持，当一个Bean处理完一个任务之后，希望另外一个Bean知道并能做相应的处理，这时我们就需要让一个Bean监听当前Bean所发送的事件。 　　Spring的事件需要遵循如下流程： 自定义事件，集成ApplicationEvent。 定义事件监听器，实现ApplicationListener。 使用容器发布事件。 一、自定义事件 p.
SpringBoot ApplicationEvent详解
若疆~赤云
09-04 742
进行属性绑定 spring.output.ansi.enabled org.springframework.boot.ansi.AnsiOutput#enabled 参考 Enabled 枚举类。reactor.tools.agent.ReactorDebugAgent有这个类并且spring.reactor.debug-agent.enabled属性配置为true时。
SpringBoot ApplicationEvent 事件监听机制及观察者模式
Lyndon的专栏
07-09 431
applicationEvent
spring 事件(Application Event)
weixin_33714884的博客
12-23 89
spring 事件为bean 与 bean之间传递消息。一个bean处理完了希望其余一个接着处理.这时我们就需要其余的一个bean监听当前bean所发送的事件.   spring事件使用步骤如下: 1.先自定义事件：你的事件需要继承 ApplicationEvent 2.定义事件监听器: 需要实现 ApplicationListener 3.使用容器对事件进行发布   以下例子是场景...
SpringBoot - 事件机制使用详解（ApplicationEvent、ApplicationListener）
hxf_yxh的博客
12-14 1105
从 Spring 4.1 开始，可以使用 @EventListener 注解的方法，以自动注册与该方法签名匹配的 ApplicationListener（监听器类同样需要注册为 Spring 的组件）。在下面的代码中，#event.message == ‘hello’ 是一个 SpEL 表达式，表示当事件的 message 属性值为 hello 时，事件监听器才会被执行。方法调用：使用 () 操作符调用对象的方法，例如，object.method() 表示调用对象 object 的方法 method。
springboot 事件Application Event
虾米大王的学习历程
08-10 91
*** 自定义事件类*//*** 来源*/return msg;@Override。
springboot事件监听使用
09-12
在Spring Boot中，你可以使用事件监听器来处理应用程序中的事件。以下是使用Spring Boot的事件监听的基本步骤： 1. 创建一个事件类：创建一个继承自ApplicationEvent的自定义事件类。例如，你可以创建一个名为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值