• 深入理解:Spring监听器使用方法与监听器的底层原理


    一·监听器的底层逻辑与作用:

    简单来说就是,当目标对象出现某个特定事件的时候,目标对象就会自动调用某个方法(以作为对这个特定事件的响应),执行完该方法之后,再继续执行目标对象的后续操作。(当然也可能是异步多线程调用该方法。)

    注意:
    (1)目标对象又称事件源
    (2)特定事件又称事件对象
    (3)自动调用的某个方法若在其他类里面,那么这个类就叫监听器
    (4)网上很多博客帖子说什么监听到事件源,就给监听者发送消息等等,感觉就很扯淡,一句话的事情说的非常复杂。

    二·关于监听器的一些个人见解:

    (1)监听器在程序开发中,实际上是一种开发风格或者设计模式,用不用其实都能实现需求结果。

    例如:MVC三层架构开发,如果我一定要把所有代码写在控制层,这也是可以实现功能需求的,只是不太利于后面扩展延伸与二次开发罢了。

    (2)利用监听器可以在各种地方获取事件源对象的所有信息

    (3)利用监听器可以对事件源对象进行各种干预,而且是那种自动干预(当然这需要提前部署好监听器才行)

    三·模拟实现一个原生的监听器案例:利用监听器设计模式

    第一步:创建一个普通Person类,声明一个普通方法

    在这里插入图片描述

    public class Person {
    
        public void depart(){
            System.out.println("大军出征!");
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    第二步:确定需求

    每次person对象调用depart方法时,利用一个事件触发监听器,先打印 “粮草先行!” 再执行后续操作。

    (1)目标对象:Person类对象调用depart方法时
    (2)特定事件:一个事件对象
    (3)监听器action:每次调用depart方法时,先打印 “粮草先行!”

    第三步:创建一个事件,Event类

    事件类主要起一个作用:那就是通过事件对象可以获取事件源对象,监听器也许会用上!
    在这里插入图片描述

    public class Event {
    
        //事件源
        private Person person;
    
        //无参构造
        public Event() {
        }
    
        //利用有参构造进行赋值
        public Event(Person person) {
            this.person = person;
        }
    
        //获取事件源
        public Person getResource() {
            return person;
        }
    }
    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    第四步:创建一个自定义监听器,MyPersonListener类

    其实本质就是一个普通类里面声明一个普通方法!监听器里面也可以根据事件对象获取事件源对象,然后进行一系列处理。
    在这里插入图片描述

    public class MyPersonListener{
    
        public void print(Event event){
            //获取事件源对象
            Person person = event.getResource();
            System.out.println("粮草先行!");
        }
    }
    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    第五步:修改事件源,Person类

    不能使用get/set方法、构造方法赋值,需要专门声明一个方法进行赋值,这就是注册监听器方法!
    在这里插入图片描述

    public class Person {
    
        private MyPersonListener myPersonListener;
    
        public void depart(){
            //调用监听器的打印方法:粮草先行!
            myPersonListener.print(new Event(this));
            System.out.println("大军出征!");
        }
    
        public void registerListener(MyPersonListener myPersonListener){
            this.myPersonListener = myPersonListener;
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    第六步:测试结果

    一旦调用depart方法,就会先去调用监听器的print方法;这样就相当于把Person类的depart方法监控起来了,也就相当于将事件源的信息告诉了另一个类监听器!!!
    在这里插入图片描述

    @Test
        public void test2(){
            Person person = new Person();
            //注册监听器
            person.registerListener(new MyPersonListener());
            //调用原方法
            person.depart();
        }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    第七步:总结

    (1)监听器的底层原理其实挺简单的,但是实现起来还是要弄好几步的,感觉还不如直接进行逻辑判断来的方便,似乎走了弯路。

    (2)监听器实现的核心就是:在事件源对象中的某个地方,去调用监听器中的某个方法;同时监听器里面可以获取当前事件源对象的所有信息,并进行一系列处理,再返回原方法继续执行后续操作。

    (3)监听器开发风格,在一般实际企业开发中用的很少,因为根据可能情况直接进行逻辑判断,代理类,拦截器等等都可以实现监听器的功能。

    (4)显然要是监听器每次都是如此麻烦配置的话,应该就没人使用了;我们最终想要的效果是:在一个目标类中,一旦手动发布某个事件,就会立即触发一个监听器方法进行自动调用执行。JDK、Spring底层都对监听器进行了相应的优化改进。

    四·Spring监听器的配置步骤

    1.自定义事件:需要继承ApplicationEvent类

    在这里插入图片描述

    public class MyEvent extends ApplicationEvent{
    
        public MyEvent(Object source, Clock clock) {
        	//调用父类构造方法
            super(source, clock);
        }
    
        public MyEvent(Object source) {
        	//调用父类构造方法
            super(source);
        }
    
    
        public void print(){
            System.out.println("事件方法");
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    注意:为什么不能交给spring管理,因为IOC容器默认使用类的无参构造创建bean实例对象,这个类不能有无参构造,因此交给spring会报缺少必要参数异常

    2.自定义监听器:需要实现ApplicationListener接口

    在这里插入图片描述

    @Component
    public class MyTestListener implements ApplicationListener<MyEvent> {
    
        public void write(){
            System.out.println("这是监听器中的一个方法");
        }
    
        /**
         * Handle an application event.
         *
         * @param event the event to respond to
         */
        @Override
        public void onApplicationEvent(MyEvent event) {
            System.out.println("app监听器方法");
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    3.自定义事件源:提前在事件源里面配置好,到时候才能自动触发;否则发布事件到时候就相当于去调用监听器方法了!

    在这里插入图片描述

    @Repository
    public class Hello {
    
        private ApplicationContext applicationContext;
    
        //执行一个普通打印
        public void print(){
            System.out.println("这是普通类中的一个方法");
            //利用IOC容器发布一个事件,进而触发监听器的方法
            applicationContext.publishEvent(new MyEvent(this));
        }
    
        //注册IOC容器
        public void registerApplicationContext(ApplicationContext applicationContext){
            this.applicationContext = applicationContext;
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    4.发布事件:需要利用IOC容器来发布事件,下面通过一个案例来演示

    一旦发布事件就会触发对应的监听器,换句话说就是:spring底层就会立即自动去调用对应监听器的onApplicationEvent()方法进行执行。
    在这里插入图片描述

    @SpringBootApplication
    public class DemoApplication {
    
        public static void main(String[] args) {
            ApplicationContext  applicationContext = SpringApplication.run(DemoApplication.class, args);
            //先发布一个事件
            applicationContext.publishEvent(new MyEvent(new Hello()));
    
            //创建一个事件源对象
            Hello hello = new Hello();
            //将IOC容器注册进去
            hello.registerApplicationContext(applicationContext);
            //调用事件源被监听的方法
            hello.print();
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    五·参考文献:

    1.监听器入门看这篇就够了
    https://segmentfault.com/a/1190000013240470

    2.这次终于把Spring的监听器讲明白了
    https://javayz.blog.csdn.net/article/details/121623148

    3.深入理解Spring的容器内事件发布监听机制
    https://www.cnblogs.com/takumicx/p/9972461.html

    4.spring中的监听器的使用(注解和非注解方式)
    https://blog.csdn.net/erbao_2014/article/details/68924231

  • 相关阅读:
    Android studio 断点调试、日志断点
    java计算机毕业设计ssm+vue二手手机销售平台
    西山科技将于12月6日上会:年收入2亿元,耗材收入成为新增长点
    Docker遇到的一些问题和感想
    34、幂等性
    数组逆序.
    shell脚本:if语句
    无涯教程-JavaScript - WORKDAY.INTL函数
    哪里下载Mac上最全面的系统清理工具,CleanMyMac X4.15中文版永久版资源啊
    【python学习】枚举算法案例分析
  • 原文地址:https://blog.csdn.net/weixin_48033662/article/details/126337805