SpringBoot--自定义事件--同步与异步

朱雀 2023-10-02 14:28 3阅读 0赞

原文网址：[SpringBoot--自定义事件--同步与异步\_IT利刃出鞘的博客-CSDN博客][SpringBoot--_--_IT_-CSDN]

## 简介 ##

**说明**

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

**系列文章**

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

**事件监听简述**

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

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

**同步与异步监听**

<table style="width:647px;"> 
 <tbody> 
 <tr> 
 <td style="width:85px;"> 监听方式 </td> 
 <td style="width:277px;"> 特点 </td> 
 <td style="width:282px;"> 使用时机 </td> 
 </tr> 
 <tr> 
 <td style="width:85px;"> 同步监听 </td> 
 <td style="width:277px;"> 发布器线程与监听器线程处于同一线程 </td> 
 <td style="width:282px;"> 1.监听逻辑处理较快 2.需要紧接着根据监听器追踪业务线程 </td> 
 </tr> 
 <tr> 
 <td style="width:85px;"> 异步监听 </td> 
 <td style="width:277px;"> 发布器线程与监听器线程处于不同线程 </td> 
 <td style="width:282px;"> 1.监听逻辑处理比较耗时 2.追求响应性能 </td> 
 </tr> 
 </tbody> 
</table>

**事件的顺序**

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

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

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

1. @Component+@EventListerner+实现Ordered
2. 实现 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
        private 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_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

启动后，访问：[http://localhost:8080/test1][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顺序颠倒，则输出结果如下：

### 异步监听(无序) ###

上边是文章的部分内容，为便于维护，全文已转移到此网址：[SpringBoot-自定义事件-同步与异步 - 自学精灵][SpringBoot-_-_ -]

[SpringBoot--_--_IT_-CSDN]: https://knife.blog.csdn.net/article/details/121234817
[SpringBoot--_--_IT_-CSDN 1]: https://knife.blog.csdn.net/article/details/125396949
[SpringBoot--_IT_-CSDN]: https://knife.blog.csdn.net/article/details/125396901
[http_localhost_8080_test1]: http://localhost:8080/test1
[SpringBoot-_-_ -]: https://learn.skyofit.com/archives/2285