SpringBoot实现自定义事件的方法详解

这篇文章将用实例来和大家介绍一下如何在SpringBoot中自定义事件来使用观察者模式。文中的示例代码讲解详细，对我们学习SpringBoot有一定的帮助，需要的可以参考一下

简介

说明

本文用实例来介绍如何在SpringBoot中自定义事件来使用观察者模式。

事件的顺序

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

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

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

@Component+@EventListerner+实现Ordered
实现 ApplicationListener+@Order

步骤1：自定义事件

通过继承ApplicationEvent来自定义事件。

构造器的参数为该事件的相关数据对象，监听器可以获取到该数据对象，进而进行相关逻辑处理。

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

步骤2：自定义监听器

方案1：ApplicationListener

法1：@EventListener

监听单个事件

package com.example.event; import org.springframework.context.event.EventListener; import org.springframework.stereotype.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.ApplicationEvent; import org.springframework.context.event.EventListener; import org.springframework.stereotype.Component; public class MyListener { @EventListener({MyEvent.class}) public void abc(ApplicationEventevent) { System.out.println("监听器：      " + "MyListener"); System.out.println("  线程：      " + Thread.currentThread().getName()); System.out.println("  事件：      " + event); System.out.println("  事件的数据： " + event.getSource()); } }

上边的办法比较好，因为不需要类型转换了。直接就能确定是MyEvent类型。

监听多个事件

事件进来之后，可以使用if(event instanceOf MyEvent.class)来判断是哪种事件。

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

监听所有ApplicationEvent

若使用这种写法，启动时会打印很多Spring自带的事件。任意ApplicationEvent都会进入这里边。

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

法2：实现ApplicationListener接口

public class MyListener implements ApplicationListener{ public void onApplicationEvent(MyEvent event){ System.out.println("监听器：     " + "MyListener"); System.out.println("  所在线程： " + Thread.currentThread().getName()); System.out.println("  事件：     " + event); System.out.println("  事件的数据：" + event.getSource()); } }

方案2：SmartApplicationListener

源码如下

public interface SmartApplicationListener extends ApplicationListener, Ordered { boolean supportsEventType(Class var1); default boolean supportsSourceType(@Nullable Class sourceType) { return true; } default int getOrder() { return 2147483647; } }

supportsEventType：支持的事件的类型

supportsSourceType：支持的数据的类型

getOrder：2147483641：是2^31-1，也就是32位的int的最大正数。

示例

事件

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.ApplicationEvent; import org.springframework.context.event.SmartApplicationListener; import org.springframework.stereotype.Component; @Component public class MyListener implements SmartApplicationListener { @Override public boolean supportsEventType(Class aClass) { return aClass == MyEvent.class; } @Override public boolean supportsSourceType(Class sourceType) { return sourceType == String.class; } @Override public int getOrder() { return 2; } @Override public void onApplicationEvent(ApplicationEvent event) { System.out.println("监听器：      " + "MyListener"); System.out.println("  所在线程：  " + Thread.currentThread().getName()); System.out.println("  事件：      " + event); System.out.println("  事件的数据：" + event.getSource()); System.out.println("  是MyEvent？：" + (event instanceof MyEvent)); } }

监听器2

package com.example.event; import org.springframework.context.ApplicationEvent; import org.springframework.context.event.SmartApplicationListener; import org.springframework.stereotype.Component; @Component public class MyListener2 implements SmartApplicationListener { @Override public boolean supportsEventType(Class aClass) { return aClass == MyEvent.class; } @Override public boolean supportsSourceType(Class sourceType) { return sourceType == String.class; } @Override public int getOrder() { return 1; } @Override public void onApplicationEvent(ApplicationEvent event) { System.out.println("监听器：      " + "MyListener2"); System.out.println("  所在线程：  " + Thread.currentThread().getName()); System.out.println("  事件：      " + event); System.out.println("  事件的数据：" + event.getSource()); System.out.println("  是MyEvent？：" + (event instanceof MyEvent)); } }

发布器

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.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.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-2
监听器： MyListener2
所在线程： http-nio-8080-exec-2
事件： com.example.event.MyEvent[source=Hello]
事件的数据：Hello
是MyEvent？：true
监听器： MyListener
所在线程： http-nio-8080-exec-2
事件： com.example.event.MyEvent[source=Hello]
事件的数据：Hello
是MyEvent？：true

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

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

步骤3：注册监听器

方式	适用范围	能否搭配@Async注解，进行异步监听
@Component	所有监听器	能
application.yml中添加配置	实现ApplicationListener接口的监听器	不能
启动类中注册	实现ApplicationListener接口的监听器	不能

法1：@Component（适用于所有监听器）

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.ApplicationListener; import org.springframework.stereotype.Component; @Component public class MyListener2 implements ApplicationListener { @Override public void onApplicationEvent(MyEvent event) { System.out.println("监听器：" + "MyListener2"); System.out.println("线程：" + Thread.currentThread().getName()); System.out.println("事件：" + event); System.out.println("事件的数据：" + event.getSource()); } }

法2：application.yml中添加配置

只适用于实现ApplicationListener接口的监听器

context:
listener:
classes: com.example.event.MyListener,com.example.event.MyListener2

法3：启动类中注册

只适用于实现ApplicationListener接口的监听器

package com.example; import com.example.event.MyListener; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.context.ConfigurableApplicationContext; @SpringBootApplication public class DemoApplication { public static void main(String[] args) { // 原来是这样的：SpringApplication.run(DemoApplication.class, args); ConfigurableApplicationContext context = SpringApplication.run(DemoApplication.class, args); context.addApplicationListener(new MyListener()); } }

步骤4：发布事件

法1：注入ApplicationContext，调用其publishEvent方法

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) { applicationContext.publishEvent(new MyEvent(message)); } }

法2：启动类中发布

package com.example; import com.example.event.MyEvent; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.context.ConfigurableApplicationContext; @SpringBootApplication public class DemoApplication { public static void main(String[] args) { //原来是：SpringApplication.run(DemoApplication.class, args); ConfigurableApplicationContext context =SpringApplication.run(DemoApplication.class, args); context.publishEvent(new MyEvent("Hello")); } }

以上就是SpringBoot实现自定义事件的方法详解的详细内容，更多关于SpringBoot自定义事件的资料请关注0133技术站其它相关文章！

以上就是SpringBoot实现自定义事件的方法详解的详细内容，更多请关注0133技术站其它相关文章！