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

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

注意：
（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