Spring Event 事件发布/监听机制 详解并使用

Spring的事件监听(也叫事件驱动)是观察者模式的一种实现，只要是观察者模式，就含有主题（针对该主题的事件），发布者（发布主题或事件），订阅者（监听主题的人）。有三个部分组成，事件（ApplicationEvent)、监听器(ApplicationListener)和事件发布操作。

作用：

使用事件机制我们可以将相互耦合的代码解耦，从而方便功能拓展和调整。

1. 观察者模式简介

当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。

比如，当一个对象被修改时，则会自动通知它的依赖对象。观察者模式属于行为型模式。

2. 观察者模式角色

• Subject：抽象主题（抽象被观察者），抽象主题角色把所有观察者对象保存在一个集合里，每个主题都可以有任意数量的观察者，抽象主题提供一个接口，可以增加和删除观察者对象。

• ConcreteSubject：具体主题（具体被观察者），该角色将有关状态存入具体观察者对象，在具体主题的内部状态发生改变时，给所有注册过的观察者发送通知。

• Observer：抽象观察者，是观察者者的抽象类，它定义了一个更新接口，使得在得到主题更改通知时更新自己。

• ConcrereObserver：具体观察者，实现抽象观察者定义的更新接口，以便在得到主题更改通知时更新自身的状态。

3. 事件机制实现方式

实现Spring事件机制主要有4个类：

1. ApplicationEvent：事件，每个实现类表示一类事件，可携带数据。
2. ApplicationListener：事件监听器，用于接收事件处理时间。
3. ApplicationEventMulticaster：事件管理者，用于事件监听器的注册和事件的广播。
4. ApplicationEventPublisher：事件发布者，委托ApplicationEventMulticaster完成事件发布。

3.1 ApplicationEvent

ApplicationEvent：应用事件，职责为定义业务

Spring 提供了一个继承于java.util.EventObject 类的ApplicationEvent的的抽象类，并提供了应用上线文事件的抽象实现ApplicationContextEvent 下面的容器关闭、刷新、启动、停止等容器事件 以及RequestHandledEvent(http 请求处理完成事件)，可自定义
事件（只需要实现ApplicationEvent 抽象类定义有参构造函数即可，source表示事件源，（ 可按照自己的需求制定）

自定义event代码实例：

public class TestEvent extends ApplicationEvent {
    private String message;

    public TestEvent(Object source, String message) {
        super(source);
        this.message = message;
    }

    public TestEvent(String message) {
        super(message);
        this.message = message;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

3.2 ApplicationListener

ApplicationListener：事件监听器,职责为处理事件广播器发布的事件。

Spring提供了继承于java.util.EventListener接口的应用监听器接口， ApplicationListener，此接口源码：

@FunctionalInterface
public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {

	/**
	 * Handle an application event.
	 * @param event the event to respond to
	 */
	void onApplicationEvent(E event);

}

并提供了两个实现：SmartApplicationListener和GenericApplicationListener接口。

事件机制监听的方式有两种：

1. 实现ApplicationListener接口
2. EventListener注解形式

代码实例：

@Log4j2
@Component
public class AEventListener implements ApplicationListener<TestEvent> {
    @Override
    public void onApplicationEvent(TestEvent event) {
        //逻辑处理
    }
}

@Log4j2
@Component
public class AEventListener implements ApplicationListener<TestEvent> {
    @Async
    @EventListener
    public void listener(TestEvent event) throws InterruptedException {
        Thread.sleep(2000);
        log.info("监听到数据：{}", event.getMessage());
    }
}

3.2.1 SmartApplicationListener

提供了监听器对泛型事件的支持，spring3.0 添加的

源码：

public interface SmartApplicationListener extends ApplicationListener<ApplicationEvent>, Ordered {
    boolean supportsEventType(Class<? extends ApplicationEvent> var1);
    boolean supportsSourceType(Class<?> var1);
}

3.2.2 GenericApplicationListener

增强对泛型事件的支持（支持泛型方式不同与SmartApplicationListener）,spring4.2 添加的。

源码：

public interface GenericApplicationListener extends ApplicationListener<ApplicationEvent>, Ordered {
    boolean supportsEventType(ResolvableType var1);
    boolean supportsSourceType(Class<?> var1);
}

3.3 ApplicationEventMulticaster

事件广播器，职责为将EventPubsher(事件发布者)发布的event 广播给事件EventListener(事件监听器)。

Spring提供了默认的实现SimpleApplicationEventMulticaster，如果用户没有配置自定义事件广播器，
则会默认使用SimpleApplicationEventMulticaster作为事件广播器。在容器刷新的过程中会实例化、初始化事件广播器。

3.4 ApplicationEventPublisher

事件发布者，职责为发布事件。
spring的ApplicationContext 本来就实现了ApplicationEventPublisher接口，因此应用上下文本来就是
一个事件发布者，在AbstractApplicationContext中实现了事件发布的业务。

如何发布事件呢

3.4.1 发布方式1

直接注入ApplicationContext:

@Autowired
private ApplicationContext applicationContext;
applicationContext.publishEvent();

3.4.2 发布方式2

直接注入ApplicationEventPublisher:

@Autowired
private ApplicationEventPublisher applicationEventPublisher;
applicationEventPublisher.publishEvent(myEvent)

3.4.3 发布方式3

@Service
public class PublishEvent implements ApplicationEventPublisherAware {
    public static ApplicationEventPublisher eventPublisher = null;
    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
        eventPublisher.publishEvent("123");
    }
}

4. 代码实现

4.1 创建事件

public class TestEvent extends ApplicationEvent {
    private String message;

    public TestEvent(String message) {
        super(message);
        this.message = message;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

如定义一个事件，对一个字符型数据处理。

4.2 创建发布者

@Service
public class PublishEvent {
    @Autowired
    private ApplicationEventPublisher applicationEventPublisher;

    public void publish(String message) {
        applicationEventPublisher.publishEvent(new TestEvent(message));
    }
}

4.3 创建监听者

@Log4j2
@Component
public class AEventListener {
    @EventListener
    public void listener(TestEvent event) {
        log.info("监听到数据1：{}", event.getMessage());
    }
}

调用接口

@RequestMapping("pub")
public void pub() {
    for (int i = 0; i < 5; i++) {
        publishEvent.publish("你若为我繁华，你好呀：" + (i + 1));
    }
}

事件监听器默认是同步阻塞的

这里你会不会有疑问，啥是同步阻塞呢，我这里举一个例子来说明：

我一次创建5个事件，调整监听处理代码

@Log4j2
@Component
public class AEventListener {
    @Async
    @EventListener
    public void listener(TestEvent event) throws InterruptedException {
        Thread.sleep(2000);
        log.info("监听到数据：{}", event.getMessage());
    }
}

sleep2秒在执行

看效果：

就类似于：吃饭和看电视，同步阻塞就是吃完饭才开始看电视，同一时间只做一件事情。

4.4 开启异步：

启动类增加此注解，开启异步支持。

@EnableAsync

方法增加@Async注解，表示该方法为异步方法。重启再次调用：

异步执行。