spring监听机制——观察者模式的应用

使用方法

spring监听模式需要三个组件：

1. 事件，需要继承ApplicationEvent，即观察者模式中的"主题"，可以看做一个普通的bean类，用于保存在事件监听器的业务逻辑中需要的一些字段；

2. 事件监听器，需要实现ApplicationListener<E extends ApplicationEvent>，即观察者模式中的"观察者"，在主题发生变化时收到通知，并作出相应的更新，加泛型表示只监听某种类型的事件；

3. 事件发布器，需要实现ApplicationEventPublisherAware，获取spring底层组件ApplicationEventPublisher，并调用其方法发布事件，即"通知"观察者。

其中，事件监听器和事件发布器需要在springIOC容器中注册。

示例Demo

事件类

import org.springframework.context.ApplicationEvent;

/**
* spring监听机制中的"事件"
* created on 2019-04-15
*/
public class BusinessEvent extends ApplicationEvent {

//事件的类型
private String type;

/**
* Create a new ApplicationEvent.
*
* @param source the object on which the event initially occurred (never {@code null})
*               即事件是在哪个对象上发生的
*/
public BusinessEvent(Object source, String type) {
super(source);
this.type = type;
}

public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
}

事件监听器

import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

/**
* spring监听机制中"监听器"
* created on 2019-04-15
*/
@Component
public class BusinessListener implements ApplicationListener<BusinessEvent> {

/**
* 监听到事件后做的处理
* @param event
*/
@Override
public void onApplicationEvent(BusinessEvent event) {
System.out.println("监听到事件：" + event.getType());
}
}

事件发布器

import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationEventPublisherAware;
import org.springframework.stereotype.Component;

/**
* spring事件监听机制中的"事件发布器"
* created on 2019-04-15
*/
@Component
public class BusinessPublisher implements ApplicationEventPublisherAware {

//spring提供的事件发布组件
private ApplicationEventPublisher applicationEventPublisher;

@Override
public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
this.applicationEventPublisher = applicationEventPublisher;
}

/**
* 发布事件
*/
public void publishEvent(BusinessEvent businessEvent) {
System.out.println("发布事件:" + businessEvent.getType());
this.applicationEventPublisher.publishEvent(businessEvent);
}
}

容器配置类

/**
* spring容器配置类
* 需要在容器中注册事件监听器、事件发布器
* created on 2019-04-15
*/
@ComponentScan(basePackages = {"cn.monolog.bennett.observer.event.listener"})
public class BeanConfig {
}

测试类

/**
* 用于测试spring事件监听
* created on 2019-04-15
*/
public class Test {

public static void main(String[] args) {
//创建springIOC容器
ApplicationContext applicationContext = new AnnotationConfigApplicationContext(BeanConfig.class);
//从容器中获取事件发布器实例
BusinessPublisher businessPublisher = applicationContext.getBean(BusinessPublisher.class);
//创建事件
BusinessEvent businessEvent = new BusinessEvent(new Test(), BusinessType.ALLOT.getName());
//发布事件
businessPublisher.publishEvent(businessEvent);
}
}

源码分析

在观察者模式中，主题发生改变时，会"通知"观察者作出相应的操作，实现方式是获取观察者列表，然后遍历、分别执行一遍其更新方法。那么，在spring事件监听中，事件发生变化时，是如何"通知"到观察者的呢？如上面的demo所述，我们是通过spring的组件ApplicationEventListener接口执行publishEvent方法发布事件的，而这个抽象方法在spring中只有一个实现，就是AbstractrApplicationContext，这是一个容器类。我们来跟进一下这个容器类对于发布事件的实现方法源码：

protected void publishEvent(Object event, @Nullable ResolvableType eventType) {
Assert.notNull(event, "Event must not be null");

// Decorate event as an ApplicationEvent if necessary
ApplicationEvent applicationEvent;
if (event instanceof ApplicationEvent) {
applicationEvent = (ApplicationEvent) event;
}
else {
applicationEvent = new PayloadApplicationEvent<>(this, event);
if (eventType == null) {
eventType = ((PayloadApplicationEvent<?>) applicationEvent).getResolvableType();
}
}

// Multicast right now if possible - or lazily once the multicaster is initialized
if (this.earlyApplicationEvents != null) {
this.earlyApplicationEvents.add(applicationEvent);
}
else {
　　　　　　　//获取事件广播器、然后广播事件
getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
}

// Publish event via parent context as well...
if (this.parent != null) {
if (this.parent instanceof AbstractApplicationContext) {
((AbstractApplicationContext) this.parent).publishEvent(event, eventType);
}
else {
this.parent.publishEvent(event);
}
}
}

粗体部分语句：首先获取事件广播器、然后广播事件。

所以问题分为两部分：如何获取事件广播器、怎样广播事件。

1. 获取事件广播器

直接跟进上述语句——getApplicationEventMulticaster()，似乎找不到答案，因为这个方法是直接返回了AbstractApplicationContext类的属性。问题转化为：AbstractApplicationContext类中的事件广播器属性是什么时候被赋值的？这就要从容器创建说起了。springIOC容器创建有一个重要步骤——刷新容器refresh()，就是在AbstractApplicationContext中定义的，这个refresh()中包含了容器创建、初始化的诸多操作，其中两个步骤与事件监听有关，看一下源码

public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
prepareRefresh();

// Tell the subclass to refresh the internal bean factory.
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

// Prepare the bean factory for use in this context.
prepareBeanFactory(beanFactory);

try {
// Allows post-processing of the bean factory in context subclasses.
postProcessBeanFactory(beanFactory);

// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);

// Register bean processors that intercept bean creation.
registerBeanPostProcessors(beanFactory);

// Initialize message source for this context.
initMessageSource();

// Initialize event multicaster for this context.
initApplicationEventMulticaster();

// Initialize other special beans in specific context subclasses.
onRefresh();

// Check for listener beans and register them.
registerListeners();

// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);

// Last step: publish corresponding event.
finishRefresh();
}

catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}

// Destroy already created singletons to avoid dangling resources.
destroyBeans();

// Reset 'active' flag.
cancelRefresh(ex);

// Propagate exception to caller.
throw ex;
}

finally {
// Reset common introspection caches in Spring's core, since we
// might not ever need metadata for singleton beans anymore...
resetCommonCaches();
}
}
}

第一个步骤是initApplicationEventMulticaster，即初始化事件广播器，继续跟进源码会发现，是先从BeanFactory中获取，如果不存在，就新建一个。第二个步骤是registerListeners，即注册监听器，从容器中获取所有ApplicationEventListener类型的组件，添加进事件广播器。

2. 广播事件

广播事件的方法是写在事件广播器的实现类——SimpleApplicationEventMulticater中的。

@Override
public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
　　 //遍历监听器，分别执行invokeListener
for (final ApplicationListener<?> listener : getApplicationListeners(event, type)) {
Executor executor = getTaskExecutor();
if (executor != null) {
executor.execute(() -> invokeListener(listener, event));
}
else {
invokeListener(listener, event);
}
}
}

从源码中可以看出，SimpleApplicationEventMulticater从容器中获取所有的监听器列表，遍历列表，对每个监听器分别执行invokeListener方法，继续跟进invokeListener方法，它会调用一个doInvokeListener，在这个doInvokeListner中：

@SuppressWarnings({"unchecked", "rawtypes"})
private void doInvokeListener(ApplicationListener listener, ApplicationEvent event) {
try {
//调用监听器实现类的onApplicationEvent方法
listener.onApplicationEvent(event);
}
catch (ClassCastException ex) {
String msg = ex.getMessage();
if (msg == null || matchesClassCastMessage(msg, event.getClass())) {
// Possibly a lambda-defined listener which we could not resolve the generic event type for
// -> let's suppress the exception and just log a debug message.
Log logger = LogFactory.getLog(getClass());
if (logger.isDebugEnabled()) {
logger.debug("Non-matching event type for listener: " + listener, ex);
}
}
else {
throw ex;
}
}
}

终于看到我们熟悉的：onApplicationEvent方法，这就是暴露在外层、供我们使用的事件监听方法；

也就是在这里，实现了观察者模式中的——"通知"观察者进行更新的操作。

转载于:https://www.cnblogs.com/dubhlinn/p/10725636.html