SSM-监听器

一时失言乱红尘 2023-10-02 17:33 10阅读 0赞

### 监听器介绍 ###

![在这里插入图片描述][76565d825a524d78b65dd0e8ae32fcca.png]  
![在这里插入图片描述][a7038f7915e24e31a05d68513819e31e.png]

![在这里插入图片描述][89ba84bcb24c41018ca642b129cf4b32.png]

**什么是监听器?**

类似于前端的事件绑定比如: click(鼠标点击事件),当用户点击某个按钮时就会触发我们提前写好的js代码,java中的监听器用于监听web应用中某些对象、信息的创建、销毁、增加，修改，删除等动作的发生，然后作出相应的响应处理。当范围对象的状态发生变化的时候，服务器自动调用监听器对象中的方法。常用于统计在线人数和在线用户，系统加载时进行信息初始化，统计网站的访问量等等。

### mvc内置的监听器怎么分类? ###

按监听的对象划分

1.  ServletContext对象监听器
2.  HttpSession对象监听器
3.  ServletRequest对象监听器

一共有哪些监听器?分别处理的是什么事情?

java中一共给我们提供了八个监听器接口,分别用于监听三个域对象,每个监听器都有专门监听的事件

**Request**

> ServletRequestListener (处理request对象创建和销毁)  
> ServleRequestAttributeListener (处理域对象中的数据添加,替换,删除)

**Session**

> HttpSessionListener (处理session对象创建和销毁)  
> HttpSessionAttributeListener 处理session域对象中的数据添加,修改,删除)  
> HttpSessionBindingListener (处理session对象监听器绑定和解绑定接口)  
> HttpSessionActivationListener (处理session对象钝化和活化状态接口)

**application**

> ServletContextListener (处理application对象创建和销毁)  
> ServletContextAttributeListener (处理application域对象中的数据添加 修改 删除)

### mvc内置监听器 ###

在使用监听器前我们先来说说创建完监听器类之后如何注册监听器呢?

**第一种方式**在 web.xml 中使用 标签配置监听器，Web 容器会自动把监听器注册到事件源中。

<listener>
            <listener-class>com.baidu.listener.MySessionListener</listener-class>
        </listener>

**第二种方式**在监听器类上使用 @WebListener 注解，可以将该 Java 类注册为一个监听器类。

@WebListener
    public class MyListener implements ServletContextListener {
        
    	// .......
    }

**注解方式实现mvc内置的监听器**

@WebListener
    public class MyListener implements ServletContextListener {
        
        public MyListener() {
        
        }
        @Override
        public void contextDestroyed(ServletContextEvent sce) {
        
        System.out.println("contextDestroyed-ServletContextEvent");
        }
        @Override
        public void contextInitialized(ServletContextEvent sce) {
        
            System.out.println("contextInitialized-ServletContextEvent");
        }
    }

或者使用使用xml方式来声明监听器

public class MyListener implements ServletContextListener {
        
    //....
    }

<listener>
        <listener-class>com.config.MyListener</listener-class>
      </listener>

### spring自定义监听器 ###

此方式必须在spring中完成(`@Component`),因为需要将监听器注入到容器里才行  
**注意:** 需要在配置文件中(component-scan)能扫描到监听器,使其能添加到容器中  
**两个监听一个定义**

> ApplicationListener这个接口是用来监听指定事件  
> SmartApplicationListener 接口针对多种事件同时监听,而且可以控制监听器执行的顺序  
> ApplicationEvent 这个类是用来创建自定义事件的

#### **spring内置事件** ####

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

#### **ApplicationListener的使用** ####

@Component
    public class MyListener implements ApplicationListener<ContextRefreshedEvent> {
        
    
        @Override
        public void onApplicationEvent(ContextRefreshedEvent contextRefreshedEvent) {
        
            System.out.println("所有的Bean被成功装载");
        }
    }

当项目启动成功后,可以从控制台中看到`所有的Bean被成功装载`

#### **SmartApplicationListener的使用** ####

这个类主要就是同时管理多个事件,并且还能指定监听器的执行顺序

package com.config;
    
    import org.springframework.context.ApplicationEvent;
    import org.springframework.context.event.ContextRefreshedEvent;
    import org.springframework.context.event.ContextStartedEvent;
    import org.springframework.context.event.SmartApplicationListener;
    import org.springframework.stereotype.Component;
    @Component
    public class MyListener implements SmartApplicationListener {
        
    
        //监听的事件类型 ,如果返回true那么就执行onApplicationEvent
    //    @Override
    //    public boolean supportsEventType(Class<? extends ApplicationEvent> aClass) {
        
    //        return false;
    //    }
    
        @Override
        public boolean supportsEventType(Class<? extends ApplicationEvent> aClass) {
        
            return ContextRefreshedEvent.class==aClass|| ContextStartedEvent.class==aClass;
        }
    
    
        // 值越大优先越小, 可以是负数,Order配置上限和下限是int最大值和最小值
        @Override
        public int getOrder() {
        
            return 1;
        }
        //事件执行的方法
        @Override
        public void onApplicationEvent(ApplicationEvent applicationEvent) {
        
            System.out.println("监听到ContextRefreshedEvent 或者 ContextStartedEvent事件了");
        }
    }

#### **ApplicationEvent 的使用** ####

这个类就是我们可以自己定义事件,在需要的场景进行触发,然后让Listener进行监听具体实现如下:  
**第一步先定义事件类:**

import org.springframework.context.ApplicationEvent;
    //创建添加User数据的事件
    public class AddUserEven extends ApplicationEvent {
        
        public AddUserEven(Object source) {
        
            super(source);
        }
    }

**第二步使用事件**

@RequestMapping(path = "/myListener",method = RequestMethod.GET)
        @ResponseBody
        public void myListener() {
        
            UserEntity userEntity=new UserEntity();
            userEntity.setUsername("huan");
            userEntity.setPassword("123");
            //触发事件
            SpringContextHolder.getApplicationContext().publishEvent(new AddUserEven(userEntity));
        }

**第三步监听事件**

import com.ssm.entity.UserEntity;
    import org.springframework.context.ApplicationListener;
    import org.springframework.stereotype.Component;
    @Component
    public class MyListener implements ApplicationListener<AddUserEven> {
        
    
        @Override
        public void onApplicationEvent(AddUserEven addUserEven) {
        
            UserEntity userEntity= (UserEntity)addUserEven.getSource();
            System.out.println("监听: "+userEntity);
    
        }
    }

### 异步执行监听器 ###

使用spring自带的异步注解,在使用前我们需要配置线程池

import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.scheduling.annotation.AsyncConfigurer;
    import org.springframework.scheduling.annotation.EnableAsync;
    import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
    
    import java.lang.reflect.Method;
    import java.util.concurrent.Executor;
    
    @Configuration
    @EnableAsync
    public class AppAsyncConfig implements AsyncConfigurer {
        
    
        @Override
        public Executor getAsyncExecutor() {
        
            ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
            executor.setCorePoolSize(7);
            executor.setMaxPoolSize(42);
            executor.setQueueCapacity(11);
            executor.setThreadNamePrefix("MyExecutor-");
            executor.initialize();
            return executor;
        }
    
        @Override
        public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        
            return new CustomAsyncExceptionHandler();
        }
    
        /**
         * 处理异步方法中未捕获的异常
         */
        static class CustomAsyncExceptionHandler implements AsyncUncaughtExceptionHandler {
        
    
            @Override
            public void handleUncaughtException(Throwable throwable, Method method, Object... obj) {
        
                throwable.printStackTrace(); //打印出现的异常堆栈
            }
    
        }
    
    }

使用方式在监听器的方法上添加@Async:

import com.ssm.entity.UserEntity;
    import org.springframework.context.ApplicationListener;
    import org.springframework.core.Ordered;
    import org.springframework.scheduling.annotation.Async;
    import org.springframework.stereotype.Component;
    @Component
    public class MyListener implements ApplicationListener<AddUserEven>  , Ordered {
        
        @Async  // 异步
        @Override
        public void onApplicationEvent(AddUserEven addUserEven) {
        
            UserEntity userEntity= (UserEntity)addUserEven.getSource();
            System.out.println("监听: "+userEntity);
    
        }
        @Override
        public int getOrder() {
        
            return 0;
        }
    }

### 控制监听器的执行顺序 ###

我们可使用SmartApplicationListener还有种方案是继承Ordered接口或者在类上添加@Order(x)来实现  
`import org.springframework.core.annotation.Order;`  
场景: 我们有多个监听器都同时监听一个事件的时候,并且需要有先后执行顺序,这时候我们就需要来使用`上述方式` 来解决此问题,演示如下:

@Component
    public class MyListener implements ApplicationListener<AddUserEven>  , Ordered {
        
    
        @Override
        public void onApplicationEvent(AddUserEven addUserEven) {
        
            UserEntity userEntity= (UserEntity)addUserEven.getSource();
            System.out.println("监听: "+userEntity);
    
        }
        //控制监听器执行的顺序,值越大优先越小, 可以是负数,Order配置上限和下限是int最大值和最小值
        @Override
        public int getOrder() {
        
            return 0;
        }
    }

点赞 -收藏-关注-便于以后复习和收到最新内容有其他问题在评论区讨论-或者私信我-收到会在第一时间回复如有侵权，请私信联系我感谢,配合,希望我的努力对你有帮助^\_^

![ceaefc422a4745479fc1e8cfd2bdb74e.jpg][]

[76565d825a524d78b65dd0e8ae32fcca.png]: https://img-blog.csdnimg.cn/76565d825a524d78b65dd0e8ae32fcca.png
[a7038f7915e24e31a05d68513819e31e.png]: https://img-blog.csdnimg.cn/a7038f7915e24e31a05d68513819e31e.png
[89ba84bcb24c41018ca642b129cf4b32.png]: https://img-blog.csdnimg.cn/89ba84bcb24c41018ca642b129cf4b32.png
[ceaefc422a4745479fc1e8cfd2bdb74e.jpg]: https://img-blog.csdnimg.cn/ceaefc422a4745479fc1e8cfd2bdb74e.jpg