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方法，这就是暴露在外层、供我们使用的事件监听方法；

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