springboot监听器的使用（ApplicationListener、SmartApplicationListener、@EventListener）

曾经终败给现在 2023-09-25 14:31 43阅读 0赞

#### 目录 ####

*  前言
 *  1. ApplicationListener
 *   *  1. 简单的全局监听
     *  2. 定时任务
     *  3. 监听自定义事件
 *  2. SmartApplicationListener
 *   *  1. 简单使用
     *  2. 方法介绍
 *  3. @EventListener

## 前言 ##

**监听器：** 当某个事件触发的时候，就会执行的方法块。

springboot提供了两个接口来实现监听：*ApplicationListener*、*SmartApplicationListener*，如下图。显而易见，*SmartApplicationListener* 是 *ApplicationListener* 的子类，故而其功能要强于 *ApplicationListener*。  
![6b347cdedde34baa8ea568a7437644a5.png][]  
![aa30ec15f1354176bb6b3f8622986fb1.png][]

当然，springboot很贴心地提供了一个 *@EventListener* 注解来实现监听。

## 1. ApplicationListener ##

### 1. 简单的全局监听 ###

首先，先来简单体验一下监听器的功能。

**需求：** 在spring容器初始化完成之后就开始监听，并打印日志。

**实现：**

*  准备springboot工程（依赖：springboot、lombok）
 *  写一个监听器
    
        @Slf4j
        @Component
        public class MyTask implements ApplicationListener<ContextRefreshedEvent> {
              
        
            private static boolean aFlag = false;
        
            @Override
            public void onApplicationEvent(ContextRefreshedEvent event) {
              
                if (!aFlag) {
              
                    aFlag = true;
                    log.info("我已经监听到了");
                }
            }
        }
 *  启动项目，控制台输出如下：  
    ![223d7275407947bf930ffca42bdc201e.png][]

现在来说一下为什么要这么写监听器：

*  实现接口
    
        implements ApplicationListener<ContextRefreshedEvent>
    
    > 自定义监听器需要实现 *ApplicationListener<E extends ApplicationEvent>* 接口  
    >   
    > *ContextRefreshedEvent* 是一个事件，它会在 *spring容器初始化完成* 之后被触发，所以监听器就会在 *spring容器初始化完成之后开始监听*，所以这就是所谓的全局监听
 *  标志位 *aFlag*
    
        private static boolean aFlag = false;
    
    > *aFlag* 是一个启动标志  
    > **因为web应用会出现父子容器，这样就会触发两次监听任务**，所以需要一个标志位，保证监听任务（*log.info(“我已经监听到了”)*）只会触发一次

### 2. 定时任务 ###

**需求：** 实现一个定时任务，每间隔5秒、10秒、15秒、20秒、25秒、30秒、40秒、50秒、60秒，在控制台打印一次日志。

**实现：** 可通过多线程的方式实现

*  新建一个类 *TimerRunner* 继承 *Runnable*
 *  5秒到60秒的间隔可以通过 *枚举类实现*
    
        private enum TimerEnum {
              
            // 第5秒打印
            FIRST(1, 5 ),
            // 第10秒打印
            SECOND(2, 10),
            // 第15秒打印
            THIRD(3, 15),
            // 第20秒打印
            FOURTH(4, 20),
            // 第25秒打印
            FIFTH(5, 25),
            // 第30秒打印
            SIXTH(6, 30),
            // 第40秒打印
            SEVENTH(7, 40),
            // 第50秒打印
            EIGHTH(8, 50),
            // 第60秒打印
            NINTH(9, 60);
        
            private Integer count;
        
            private Integer time;
        
            TimerEnum(Integer count, Integer time) {
              
                this.count = count;
                this.time = time;
            }
        
            public Integer getCount() {
              
                return count;
            }
        
            public Integer getTime() {
              
                return time;
            }
        }
 *  *TimeRunner* 完整代码
    
        @Slf4j
        public class TimerRunner implements Runnable{
              
            @Override
            public void run() {
              
                // 打印次数
                int count = 1;
                SimpleDateFormat dateFormat= new SimpleDateFormat("hh:mm:ss");
                for (TimerEnum item: TimerEnum.values()) {
              
                    if (count == item.getCount()) {
              
                        if (count != 9) {
              
                            log.info("时间: " + dateFormat.format(new Date()) + "第 " + count + " 次打印，还剩余 " + (9 - count) + " 次完成打印");
                            count++;
                        } else {
              
                            log.info("最后一次打印");
                            log.info("已完成所有打印任务！");
                        }
                    }
                    try {
              
                    	// TimeUnit来sleep，可读性更好
                        TimeUnit.SECONDS.sleep(item.getTime());
                    } catch (InterruptedException e) {
              
                        throw new RuntimeException(e);
                    }
                }
            }
        
            private enum TimerEnum {
              
                // 第5秒打印
                FIRST(1, 5 ),
                // 第10秒打印
                SECOND(2, 10),
                // 第15秒打印
                THIRD(3, 15),
                // 第20秒打印
                FOURTH(4, 20),
                // 第25秒打印
                FIFTH(5, 25),
                // 第30秒打印
                SIXTH(6, 30),
                // 第40秒打印
                SEVENTH(7, 40),
                // 第50秒打印
                EIGHTH(8, 50),
                // 第60秒打印
                NINTH(9, 60);
        
                private Integer count;
        
                private Integer time;
        
                TimerEnum(Integer count, Integer time) {
              
                    this.count = count;
                    this.time = time;
                }
        
                public Integer getCount() {
              
                    return count;
                }
        
                public Integer getTime() {
              
                    return time;
                }
            }
        }
 *  *MyTask* 代码
    
        @Slf4j
        @Component
        public class MyTask implements ApplicationListener<ContextRefreshedEvent> {
              
        
            private static boolean aFlag = false;
        
            @Override
            public void onApplicationEvent(ContextRefreshedEvent event) {
              
                if (!aFlag) {
              
                    aFlag = true;
                    new Thread(new TimerRunner()).start();
                }
            }
        }
 *  控制台输出：  
    ![88104b3b9f6040949f605e1c5428387a.png][]

### 3. 监听自定义事件 ###

> Spring的 `ApplicationContext` 提供了支持事件和代码中监听器的功能。  
> 我们可以创建bean用来监听在 `ApplicationContext` 中发布的事件。`ApplicationEvent` 类在 `ApplicationContext` 接口中处理的事件，如果一个bean实现了 `ApplicationListener` 接口，当一个 `ApplicationEvent` 被发布以后，bean会自动被通知。
> 
> --------------------
> 
> 参考链接：[https://cloud.tencent.com/developer/article/1532994][https_cloud.tencent.com_developer_article_1532994]

![a2fba2b30344405cb46a547f9294c637.png][]

先来看一下 *spring的内置事件* ：

**内置事件：** 参考链接： [https://blog.csdn.net/liyantianmin/article/details/81017960][https_blog.csdn.net_liyantianmin_article_details_81017960]

<table> 
 <thead> 
  <tr> 
   <th align="left">事件</th> 
   <th align="left">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><em><strong><font>ContextRefreshedEvent</font></strong></em></td> 
   <td align="left">ApplicationContext 被初始化或刷新时，该事件被发布。这也可以在 ConfigurableApplicationContext接口中使用 refresh() 方法来发生。此处的初始化是指：所有的Bean被成功装载，后处理Bean被检测并激活，所有Singleton Bean 被预实例化，ApplicationContext容器已就绪可用。</td> 
  </tr> 
  <tr> 
   <td align="left"><em><strong><font>ContextStartedEvent</font></strong></em></td> 
   <td align="left">当使用 ConfigurableApplicationContext （ApplicationContext子接口）接口中的 start() 方法启动 ApplicationContext 时，该事件被发布。你可以调查你的数据库，或者你可以在接受到这个事件后重启任何停止的应用程序。</td> 
  </tr> 
  <tr> 
   <td align="left"><em><strong><font>ContextStoppedEvent</font></strong></em></td> 
   <td align="left">当使用 ConfigurableApplicationContext 接口中的 stop() 停止 ApplicationContext 时，发布这个事件。你可以在接受到这个事件后做必要的清理的工作。</td> 
  </tr> 
  <tr> 
   <td align="left"><em><strong><font>ContextClosedEvent</font></strong></em></td> 
   <td align="left">当使用 ConfigurableApplicationContext 接口中的 close() 方法关闭 ApplicationContext 时，该事件被发布。一个已关闭的上下文到达生命周期末端；它不能被刷新或重启。</td> 
  </tr> 
  <tr> 
   <td align="left"><em><strong><font>RequestHandledEvent</font></strong></em></td> 
   <td align="left">这是一个 web-specific 事件，告诉所有 bean HTTP 请求已经被服务。只能应用于使用DispatcherServlet的Web应用。在使用Spring作为前端的MVC控制器时，当Spring处理用户请求结束后，系统会自动触发该事件。</td> 
  </tr> 
 </tbody> 
</table>

**自定义监听事件：**

*  *extends ApplicationEvent* 自定义事件
    
        public class MyEvent extends ApplicationEvent {
              
        
            private String time = new SimpleDateFormat("hh:mm:ss").format(new Date());
            private String msg;
        
            public MyEvent(Object source, String msg) {
              
                super(source);
                this.msg = msg;
            }
        
            public MyEvent(Object source) {
              
                super(source);
            }
        
            public String getTime() {
              
                return time;
            }
        
            public void setTime(String time) {
              
                this.time = time;
            }
        
            public String getMsg() {
              
                return msg;
            }
        
            public void setMsg(String msg) {
              
                this.msg = msg;
            }
        }
 *  监听器
    
        @Slf4j
        @Component
        public class MyTask implements ApplicationListener {
              
        
            private static boolean aFlag = false;
        
        
            @Override
            public void onApplicationEvent(ApplicationEvent event) {
              
                if (event instanceof ContextRefreshedEvent) {
              
                    log.info("监听到 ContextRefreshedEvent...");
                }
                if (event instanceof MyEvent) {
              
                    log.info("监听到 MyEvent...");
                    MyEvent myEvent = (MyEvent) event;
                    System.out.println("时间：" + myEvent.getTime() + " 信息：" + myEvent.getMsg());
                }
            }
        }
 *  触发事件  
    **自定义监听事件需要主动触发**
    
        @SpringBootApplication
        public class TaskApplication {
              
            public static void main(String[] args) {
              
                ConfigurableApplicationContext run = SpringApplication.run(TaskApplication.class, args);
                MyEvent event = new MyEvent("event", "忙中岁月忙中遣，我本愚来性不移");
                // 发布事件
                run.publishEvent(event);
            }
        }
    
    也可以这样触发，美观一点
    
        @SpringBootApplication
        public class TaskApplication implements CommandLineRunner {
              
            public static void main(String[] args) {
              
                SpringApplication.run(TaskApplication.class, args);
            }
        
            @Resource
            private ApplicationContext applicationContext;
        
            @Override
            public void run(String... args) throws Exception {
              
                MyEvent event = new MyEvent("event", "忙中岁月忙中遣，我本愚来性不移");
                // 发布事件
                applicationContext.publishEvent(event);
        
            }
        }
 *  控制台输出  
    ![80eac96c35a24ed38fd889445e570c19.png][]

## 2. SmartApplicationListener ##

### 1. 简单使用 ###

@Slf4j
    @Component
    public class MyTask implements SmartApplicationListener {
        
        @Override
        public boolean supportsEventType(Class<? extends ApplicationEvent> eventType) {
        
            return eventType == MyEvent.class || eventType == ContextRefreshedEvent.class;
        }
    
        @Override
        public int getOrder() {
        
            return 0;
        }
    
        @Override
        public void onApplicationEvent(ApplicationEvent event) {
        
            if (event instanceof ContextRefreshedEvent) {
        
                log.info("监听到 ContextRefreshedEvent...");
            }
            if (event instanceof MyEvent) {
        
                log.info("监听到 MyEvent...");
                MyEvent myEvent = (MyEvent) event;
                System.out.println("时间：" + myEvent.getTime() + " 信息：" + myEvent.getMsg());
            }
        }
    }

![a44d976840734ada9651935dddd474cc.png][]

### 2. 方法介绍 ###

public interface SmartApplicationListener extends ApplicationListener<ApplicationEvent>, Ordered {
        
    
    	boolean supportsEventType(Class<? extends ApplicationEvent> eventType);
    
    	default boolean supportsSourceType(@Nullable Class<?> sourceType) {
        
    		return true;
    	}
    
    	@Override
    	default int getOrder() {
        
    		return LOWEST_PRECEDENCE;
    	}
    
    	default String getListenerId() {
        
    		return "";
    	}
    
    }

<table> 
 <thead> 
  <tr> 
   <th align="left">方法</th> 
   <th align="left">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><em><strong><font>supportsEventType</font></strong></em></td> 
   <td align="left">确认当前监听器是否支持当前事件类型。</td> 
  </tr> 
  <tr> 
   <td align="left"><em><strong><font>supportsSourceType</font></strong></em></td> 
   <td align="left">确定此监听器是否实际支持给定的源类型。</td> 
  </tr> 
  <tr> 
   <td align="left"><em><strong><font>getOrder</font></strong></em></td> 
   <td align="left">确定此侦听器在同一事件的一组侦听器中的顺序。数值越小，优先级越高。</td> 
  </tr> 
  <tr> 
   <td align="left"><em><strong><font>getListenerId</font></strong></em></td> 
   <td align="left">返回侦听器的可选标识符。</td> 
  </tr> 
 </tbody> 
</table>

## 3. @EventListener ##

**使用：**

@Slf4j
    @Component
    public class MyTask {
        
        @EventListener
        public void onApplicationEvent(ApplicationEvent event) {
        
            if (event instanceof ContextRefreshedEvent) {
        
                log.info("监听到 ContextRefreshedEvent...");
            }
            if (event instanceof MyEvent) {
        
                log.info("监听到 MyEvent...");
                MyEvent myEvent = (MyEvent) event;
                System.out.println("时间：" + myEvent.getTime() + " 信息：" + myEvent.getMsg());
            }
        }
    }

@Slf4j
    @Component
    public class MyTask {
        
        @EventListener
        public void MyEventListener(MyEvent event) {
        
            log.info("监听到 MyEvent...");
            MyEvent myEvent = (MyEvent) event;
            System.out.println("时间：" + myEvent.getTime() + " 信息：" + myEvent.getMsg());
        }
    
        @EventListener
        public void ContextRefreshedEventListener(MyEvent event) {
        
            log.info("监听到 ContextRefreshedEvent...");
        }
    }

**指定监听事件的类型：**

@EventListener(MyEvent.class)
    
    @EventListener({
        MyEvent.class, ContextRefreshedEvent.class})

[6b347cdedde34baa8ea568a7437644a5.png]: https://img-blog.csdnimg.cn/6b347cdedde34baa8ea568a7437644a5.png
[aa30ec15f1354176bb6b3f8622986fb1.png]: https://img-blog.csdnimg.cn/aa30ec15f1354176bb6b3f8622986fb1.png
[223d7275407947bf930ffca42bdc201e.png]: https://img-blog.csdnimg.cn/223d7275407947bf930ffca42bdc201e.png
[88104b3b9f6040949f605e1c5428387a.png]: https://img-blog.csdnimg.cn/88104b3b9f6040949f605e1c5428387a.png
[https_cloud.tencent.com_developer_article_1532994]: https://cloud.tencent.com/developer/article/1532994
[a2fba2b30344405cb46a547f9294c637.png]: https://img-blog.csdnimg.cn/a2fba2b30344405cb46a547f9294c637.png
[https_blog.csdn.net_liyantianmin_article_details_81017960]: https://blog.csdn.net/liyantianmin/article/details/81017960
[80eac96c35a24ed38fd889445e570c19.png]: https://img-blog.csdnimg.cn/80eac96c35a24ed38fd889445e570c19.png
[a44d976840734ada9651935dddd474cc.png]: https://img-blog.csdnimg.cn/a44d976840734ada9651935dddd474cc.png