Question

在讲解 Spring 的时间传播器之前，我们还是先来看一下 Spring 的事件监听的简单用法。

（1）定义监听事件。

public class TestEvent extends ApplicationEvent {

public String msg;

public TestEvent (Object source) {

　super(source);

}

public TestEvent (Object source, String msg) {

　super(source);

　 this.msg = msg;

}

public void print(){

　System.out.println(msg);

}

}

（2）定义监听器。

public class TestListener implements ApplicationListener {

public void onApplicationEvent(ApplicationEvent event) {

　 if(event instanceof TestEvent){

　　 TestEvent testEvent = (TestEvent)event;

　　 testEvent .print();

　}

}

}

（3）添加配置文件。

<bean id="testListener" class="com.test.event.TestListener "/>

（4）测试。

public class Test {

　 public static void main(String[] args) {

　　 ApplicationContext context = new ClassPathXmlApplicationContext ("classpath:

　　applicationContext.xml");

　　 TestEvent event = new TestEvent ("hello",”msg”);

　　context.publishEvent(event);

　}

}

当程序运行时，Spring 会将发出的 TestEvent 事件转给我们自定义的 TestListener 进行进一步处理。

或许很多人一下子会反映出设计模式中的观察者模式，这确实是个典型的应用，可以在比较关心的事件结束后及时处理。那么我们看看 ApplicationEventMulticaster 是如何被初始化的，以确保功能的正确运行。

initApplicationEventMulticaster 的方式比较简单，无非考虑两种情况。

如果用户自定义了事件广播器，那么使用用户自定义的事件广播器。

如果用户没有自定义事件广播器，那么使用默认的 ApplicationEventMulticaster。

protected void initApplicationEventMulticaster() {

　 ConfigurableListableBeanFactory beanFactory = getBeanFactory();

　 if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {

　　 this.applicationEventMulticaster =

　　　beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME,

　　　ApplicationEventMulticaster.class);

　　 if (logger.isDebugEnabled()) {

　　　 logger.debug("Using ApplicationEventMulticaster [" + this.application

　　　 EventMulticaster + "]");

　　}

　 }else {

　　 this.applicationEventMulticaster = new SimpleApplicationEventMulticaster

　　(beanFactory);

　　beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME,

　　this.applicationEventMulticaster);

　　 if (logger.isDebugEnabled()) {

　　　 logger.debug("Unable to locate ApplicationEventMulticaster with name '" +

　　　 APPLICATION_EVENT_MULTICASTER_BEAN_NAME +

　　　 "': using default [" + this.applicationEventMulticaster + "]");

　　}

　}

}

按照之前介绍的顺序及逻辑，我们推断，作为广播器，一定是用于存放监听器并在合适的时候调用监听器，那么我们不妨进入默认的广播器实现 SimpleApplicationEventMulticaster 来一探究竟。

其中的一段代码是我们感兴趣的。

public void multicastEvent(final ApplicationEvent event) {

　 for (final ApplicationListener listener : getApplicationListeners(event)) {

　　 Executor executor = getTaskExecutor();

　　 if (executor != null) {

　　　 executor.execute(new Runnable() {

　　　　@SuppressWarnings("unchecked")

　　　　 public void run() {

　　　　listener.onApplicationEvent(event);

　　　　}

　　　});

　　}

　　 else {

　　　listener.onApplicationEvent(event);

　　}

　}

}

可以推断，当产生 Spring 事件的时候会默认使用 SimpleApplicationEventMulticaster 的 multicastEvent 来广播事件，遍历所有监听器，并使用监听器中的 onApplicationEvent 方法来进行监听器的处理。而对于每个监听器来说其实都可以获取到产生的事件，但是是否进行处理则由事件监听器来决定。