SpringBoot--自定义事件--方法/详解/实例

叁歲伎倆 2023-09-28 11:41 4阅读 0赞

原文网址：[SpringBoot--自定义事件--方法/详解/实例\_IT利刃出鞘的博客-CSDN博客][SpringBoot--_--_IT_-CSDN]

## 简介 ##

**说明**

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

**系列文章**

1.  [SpringBoot--自定义事件--方法/详解/实例\_IT利刃出鞘的博客-CSDN博客][SpringBoot--_--_IT_-CSDN]
2.  [SpringBoot--自定义事件--同步与异步\_IT利刃出鞘的博客-CSDN博客\_springboot监听器的原理和用途][SpringBoot--_--_IT_-CSDN_springboot]
3.  [SpringBoot--启动时的事件机制\_IT利刃出鞘的博客-CSDN博客][SpringBoot--_IT_-CSDN]

**事件的顺序**

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

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

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

1.  @Component+@EventListerner+实现Ordered
2.  实现 ApplicationListener<MyEvent>+@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<T>接口** ####

public class MyListener implements ApplicationListener<MyEvent>{
    
    	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<ApplicationEvent>, Ordered {
        boolean supportsEventType(Class<? extends ApplicationEvent> 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<? extends ApplicationEvent> 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<? extends ApplicationEvent> 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_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：注册监听器 ##

<table> 
 <tbody> 
  <tr> 
   <td><strong>方式</strong></td> 
   <td><strong>适用范围</strong></td> 
   <td><strong>能否搭配@Async注解，进行异步监听</strong></td> 
  </tr> 
  <tr> 
   <td><strong>@Component</strong></td> 
   <td>所有监听器</td> 
   <td>能</td> 
  </tr> 
  <tr> 
   <td><strong>application.yml中添加配置</strong></td> 
   <td>实现ApplicationListener&lt;T&gt;接口的监听器</td> 
   <td>不能</td> 
  </tr> 
  <tr> 
   <td><strong>启动类中注册</strong></td> 
   <td>实现ApplicationListener&lt;T&gt;接口的监听器</td> 
   <td>不能</td> 
  </tr> 
 </tbody> 
</table>

### **方案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<MyEvent> {
    
        @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<T>接口的监听器

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

### **方案3：启动类中注册** ###

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

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
        private 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--_--_IT_-CSDN]: https://knife.blog.csdn.net/article/details/125396949
[SpringBoot--_--_IT_-CSDN_springboot]: https://knife.blog.csdn.net/article/details/121234817
[SpringBoot--_IT_-CSDN]: https://knife.blog.csdn.net/article/details/125396901
[http_localhost_8080_test1]: http://localhost:8080/test1