一、简介

1、Spring事件监听基本原理

Spring的事件监听机制和发布订阅机制是很相似的：发布了一个事件后，监听该类型事件的所有监听器会触发相应的处理逻辑。

正如Spring官方文档上所说的，整个上就是一个观察者的模式。那么，我们不妨猜测下，Spring是如何来实现事件发布监听的：底层使用一个集合存储了所有的监听器，当发布了一个事件后，遍历事件监听器集合，然后过滤符合事件类型的监听器，最后触发相应的事件处理逻辑。

2、Spring中事件监听的相关规范

在Spring中，事件监听机制主要涉及到了一下几个关键的规范（抽象类及接口）：ApplicationEvent、ApplicationListener、ApplicationEventPublisher

• ApplicationEvent: Spring的事件是符合jdk的规范的，这个抽象类继承了jdk内置的事件规范类EventObject（即jdk建议所有的事件都继承EventObject这个类）。ApplicationEvent是Spring家的事件规范。所以我们在自定义事件的时候，可以继承与ApplicationEvent，比如，Spring家自己关于容器上下文事件就又定义了一个容器上下文的时间规范ApplicationContextEvent，它同样是继承于ApplicationEvent的，只不过扩充了获取发出事件容器的方法；今后，我们同样可以在继承于ApplicationEvent的基础上定义自己的事件规范。

• ApplicationListener：这是一个函数式接口，同样时事件监听器的规范，当监听到自己监听的事件类型时就会调用onApplicationEvent方法来执行监听逻辑

• ApplicationEventPublisher：这同样是一个函数式接口，定义了事件发布的规范，任何的事件发布器ApplicationEventPublisher都是通过调用publishEvent来进行事件的发布

二、Spring事件监听器的使用

1、自定义事件创建

在Spring中，所有的事件需要继承自ApplicationEvent，自定义事件的不同可以监听多个，一个最基础的MsgEvent如下

public class MyEvent extends ApplicationEvent {

    private String msg;

    // 必须继承实现
    public MyEvent(Object source, String msg) {
        super(source);
        this.msg = msg;
    }

    @Override
    public String toString() {
        return "MyEvent{" +
                "msg='" + msg + '\'' +
                '}';
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2、自定义监听器

2.1 方法介绍

springboot进行事件监听有四种方式，选择任意一种即可

• 将监听器装载入spring容器（常用）

• 通过@EventListener注解实现事件监听（常用）

• 手工向ApplicationContext中添加监听器

• 在application.properties中配置监听器

2.2 将监听器装载入spring容器

// 装载入spring容器中
@Slf4j
@Component
public class MyListener1 implements ApplicationListener<MyEvent> {

    @Override
    public void onApplicationEvent(MyEvent event) {
        // 这里可以自定义自己的方法
        log.info(String.format("%s监听到事件源：%s.", MyListener1.class.getName(), event.toString()));
    }
}
1
2
3
4
5
6
7
8
9
10
11

如果不加@Component注解加入Spring容器，也可以手动加入

@SpringBootApplication
public class ListenerApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(ListenerApplication.class, args);
        //装载监听
        context.addApplicationListener(new MyListener1());
    }

}
1
2
3
4
5
6
7
8
9
10

也可以通过配置文application.properties中配置监听器：context.listener.classes=com.listener.MyListener1

2.3 @EventListener注解实现事件监听

@Component
@Slf4j
public class MyListener2{
 
    // 通过注解的方法
    @EventListener(MyEvent.class)
    public void consumer(MyEvent msgEvent) {
        log.info(String.format("%s监听到事件源：%s.", MsgPublisher.class.getName(), msgEvent.toString()));
    }
}
1
2
3
4
5
6
7
8
9
10

3、事件发布

前面是消费事件，消费的前提是有事件产生，在Spring中，发布事件主要需要借助ApplicationContext来实现

@Component
@Slf4j
public class MsgPublisher implements ApplicationContextAware {

    private ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    // 发起事件通知
    public void publish(String msg) {
        applicationContext.publishEvent(new MyEvent1(this, msg));
    }

    // 通过注解的方法
    @EventListener(MyEvent.class)
    public void consumer(MyEvent msgEvent) {
        log.info(String.format("%s监听到事件源：%s.", MsgPublisher.class.getName(), msgEvent.toString()));
    }


    /**
     * 这个只是测试，到时候spring直接调用即可
    */
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(MsgPublisher.class);
        MsgPublisher msgPublisher = context.getBean(MsgPublisher.class);
        msgPublisher.publish("hello world");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32