Spring 中的Event机制

spring

参考资料:
Additional Capabilities of the ApplicationContext- https://docs.spring.io/spring-framework/reference/6.1/core/beans/context-introduction.html

[[17.行为型 - 观察者模式 (Observer Pattern)]]
[[Spring IOC 源码学习总笔记]]

Spring Event

Standard and Custom Events

Event handling in the ApplicationContext is provided through the ApplicationEvent class and the ApplicationListener interface. If a bean that implements the ApplicationListener interface is deployed into the context, every time an ApplicationEvent gets published to the ApplicationContext, that bean is notified. Essentially, this is the standard Observer design pattern.

简而言之 两点:

1. 推送到 ApplicationContext 中的事件, 都通知容器中实现 ApplicationEvent 接口的 bean.
2. this is the standard Observer design pattern 它是标准的观察者模式

观察者模式和发布-订阅模式

观察者模式的别名有发布-订阅(Publish/Subscribe)模式, 我们来看一下观察者模式与发布订阅模式结构上的区别

• 在设计模式结构上，发布订阅模式继承自观察者模式，是观察者模式的一种 实现的变体。
• 在设计模式意图上，两者关注点不同，一个关心数据源，一个关心的是事件消息。

对比标准的观察者模式:

• 观察者模式：数据源直接通知订阅者发生改变
• 发布订阅模式：数据源(被观察者) 告诉第三方(Event Channel) 发生了改变，第三方(Event Channel)再通知/广播订阅者(观察者) 发生了改变

Spring 其实基于是发布订阅模式, 主要由ApplicationEventMulticaster 管理订阅者/事件通道/广播事件;

事件模型的关键角色对象

1.ApplicationEvent 事件源(中间传递参数)

事件源对象, 在事件中传递的中间参数

org.springframework.context.ApplicationEvent

public abstract class ApplicationEvent extends EventObject {// 它继承了 java.util.EventObject/***定义在 java.util.EventObject 中, 可以通过该方法获取到事件源对象public Object getSource() {  return this.source;}***//**  * Create a new {@code ApplicationEvent} with its {@link #getTimestamp() timestamp}  * set to {@link System#currentTimeMillis()}.  * @param source the object on which the event initially occurred or with  * which the event is associated (never {@code null})  * @see #ApplicationEvent(Object, Clock)  */  public ApplicationEvent(Object source) {  super(source);  this.timestamp = System.currentTimeMillis();  }/**  * Return the time in milliseconds when the event occurred.  * 返回事件发生时间* @see #ApplicationEvent(Object)  * @see #ApplicationEvent(Object, Clock)  */  public final long getTimestamp() {  return this.timestamp;  }}

2.ApplicationListener 监听器

充当 '观察者' 角色

org.springframework.context.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);...
}

3.ApplicationEventPublisher 事件推送器

充当 '被观察者' 角色

@FunctionalInterface  
public interface ApplicationEventPublisher {/**  * Notify all <strong>matching</strong> listeners registered with this  * application of an event.  * <p>If the specified {@code event} is not an {@link ApplicationEvent},  * it is wrapped in a {@link PayloadApplicationEvent}.  * <p>Such an event publication step is effectively a hand-off to the  * multicaster and does not imply synchronous/asynchronous execution  * or even immediate execution at all. Event listeners are encouraged  * to be as efficient as possible, individually using asynchronous  * execution for longer-running and potentially blocking operations.  * @param event the event to publish  * @since 4.2  * @see #publishEvent(ApplicationEvent)  * @see PayloadApplicationEvent  */  void publishEvent(Object event);  }

4.ApplicationEventMulticaster 事件广播器

**充当 第三方(Event Channel) 角色, 它通知/广播 消息给观察者

管理/广播/群发事件, 注册事件监听器, 管理事件通道, spring 其实最终是委托给该对象广播事件的

org.springframework.context.event.ApplicationEventMulticaster

/**
* Interface to be implemented by objects that can manage a number of
**/
public interface ApplicationEventMulticaster {  /**  
* Add a listener to be notified of all events.  
* @param listener the listener to add  
* @see #removeApplicationListener(ApplicationListener)  
* @see #removeApplicationListeners(Predicate)  
*/  
void addApplicationListener(ApplicationListener<?> listener);  /**  
* Add a listener bean to be notified of all events.  
* @param listenerBeanName the name of the listener bean to add  
* @see #removeApplicationListenerBean(String)  
* @see #removeApplicationListenerBeans(Predicate)  
*/  
void addApplicationListenerBean(String listenerBeanName);  /**  
* Remove a listener from the notification list.  
* @param listener the listener to remove  
* @see #addApplicationListener(ApplicationListener)  
* @see #removeApplicationListeners(Predicate)  
*/  
void removeApplicationListener(ApplicationListener<?> listener);  /**  
* Remove a listener bean from the notification list.  
* @param listenerBeanName the name of the listener bean to remove  
* @see #addApplicationListenerBean(String)  
* @see #removeApplicationListenerBeans(Predicate)  
*/  
void removeApplicationListenerBean(String listenerBeanName);  /**  
* Remove all matching listeners from the set of registered  
* {@code ApplicationListener} instances (which includes adapter classes  
* such as {@link ApplicationListenerMethodAdapter}, e.g. for annotated  
* {@link EventListener} methods).  
* <p>Note: This just applies to instance registrations, not to listeners  
* registered by bean name.  
* @param predicate the predicate to identify listener instances to remove,  
* e.g. checking {@link SmartApplicationListener#getListenerId()}  
* @since 5.3.5  
* @see #addApplicationListener(ApplicationListener)  
* @see #removeApplicationListener(ApplicationListener)  
*/  
void removeApplicationListeners(Predicate<ApplicationListener<?>> predicate);  /**  
* Remove all matching listener beans from the set of registered  
* listener bean names (referring to bean classes which in turn  
* implement the {@link ApplicationListener} interface directly).  
* <p>Note: This just applies to bean name registrations, not to  
* programmatically registered {@code ApplicationListener} instances.  
* @param predicate the predicate to identify listener bean names to remove  
* @since 5.3.5  
* @see #addApplicationListenerBean(String)  
* @see #removeApplicationListenerBean(String)  
*/  
void removeApplicationListenerBeans(Predicate<String> predicate);  /**  
* Remove all listeners registered with this multicaster.  
* <p>After a remove call, the multicaster will perform no action  
* on event notification until new listeners are registered.  
* @see #removeApplicationListeners(Predicate)  
*/  
void removeAllListeners();  /**  
* Multicast the given application event to appropriate listeners.  
* <p>Consider using {@link #multicastEvent(ApplicationEvent, ResolvableType)}  
* if possible as it provides better support for generics-based events.  
* @param event the event to multicast  
*/  
void multicastEvent(ApplicationEvent event);  /**  
* Multicast the given application event to appropriate listeners.  
* <p>If the {@code eventType} is {@code null}, a default type is built  
* based on the {@code event} instance.  
* @param event the event to multicast  
* @param eventType the type of event (can be {@code null})  
* @since 4.2  
*/  
void multicastEvent(ApplicationEvent event, @Nullable ResolvableType eventType);  }

内置的事件类型

官方文档 - Standard and Custom Events

public class BusinessService implements ApplicationListener {@Override  public void onApplicationEvent(ApplicationEvent event) {  if(event instanceof ContextRefreshedEvent) {  //容器启动完成事件  }else if(event instanceof ContextClosedEvent) {  //容器关闭事件excutor.shutdownNow();  log.info("业务线程池终止");  }}
}

• ContextRefreshedEvent ApplicationContext容器初始化或刷新触发该事件。此处说的初始化，是指所有的bean被成功加载，后处理的bean被检测激活，所有的singleton bean被预初始化，ApplicationContext容器已就绪可用。容器完整可用

• ContextStartdEvent: 当使用ApplicationContext的子接口ConfigurableApplicationContex接口的start()方法启动ApplicationContext容器时触发该事件。容器管理生命周期的bean实例将获得一个指定的启动信号，这在经常需要停止后重新启动的场合比较常见。

• ContextClossedEvent:当使用ConfigurableApplicationContex接口的close()方法关闭ApplicationContext容器时触发该事件。

• ContextStoppedEvent:当使用ConfigurableApplicationContex接口的stop()方法使ApplicationContext容器停止时触发该事件 。此处的“停止”意味着，容器管理生命周期的bean实例将获得一个指定的停止信号。被停止的spring容器可以再次通过调用start()方法重新启动。

• RequestHandledEventWeb:相关的事件，只能应用于使用DispatcherServlet的Web应用中。在使用spring作为前端的MVC控制器时，当spring处理用户请求结束后，系统会自动触发该事件。

自定义事件实例

EventObject 事件定义

定义事件，继承 ApplicationEvent 的类成为一个事件类

@Data  
@ToString  
public class OrderProductEvent extends ApplicationEvent {    /** 该类型事件携带的信息 */  
  private String orderId;    public OrderProductEvent(Object source, String orderId) {  
    super(source);  
    this.orderId = orderId;  
  }  
}

Listener 监听定义

监听并处理事件，实现 ApplicationListener 接口或者使用 @EventListener 注解

@Slf4j  
@Component  
public class OrderProductListener implements ApplicationListener<OrderProductEvent> {    /** 使用 onApplicationEvent 方法对消息进行接收处理 */  
  @SneakyThrows  
  @Override  
  public void onApplicationEvent(OrderProductEvent event) {  
    String orderId = event.getOrderId();  
    long start = System.currentTimeMillis();  
    Thread.sleep(2000);  
    long end = System.currentTimeMillis();  
    log.info("{}：校验订单商品价格耗时：({})毫秒", orderId, (end - start));  
  }  
}

在 监听器(Listener) onApplicationEvent 中的线程与 发布(push)线程 不是同一个线程, 它们的 ThreadLocal上下文是​​完全隔离的​​。不​继承原有事务。

Push 推送定义

如何自定义push事件?
使用 ApplicationEventPublisher 和 ApplicationContext 都可

//@Autowired
//ApplicationEventPublisher publisher;@Autowired
ApplicationContext applicationContext;public void publish(String msg){applicationContext.publishEvent(new OrderProductEvent());
}