ApplicationListener机制（一）

ApplicationListener机制是Sprint提供的用于实现发布订阅功能的机制，也是观察者模式的典型实现。程序中事先注册ApplicationListener，当某些事件发生的时候通过调用ApplicationListener#onApplicationEvent就可以实现发布订阅功能。

public interface ApplicationListener extends EventListener {

	
	void onApplicationEvent(E event);
}

public abstract class ApplicationEvent extends EventObject {

	
	private static final long serialVersionUID = 7099057708183571937L;

	
	private final long timestamp;


	
	public ApplicationEvent(Object source) {
		super(source);
		this.timestamp = System.currentTimeMillis();
	}


	
	public final long getTimestamp() {
		return this.timestamp;
	}

}

在这个过程中发送器就很重要了，相当于一个中转站，而在Spring中完成这个功能的类是：SimpleApplicationEventMulticaster，他通过线程池技术实现了同步和异步执行两种方式。
该类实现了ApplicationEventMulticaster，提供注册监听器ApplicationListener和广播事件的方法multicastEvent，multicastEvent方法中从BeanFactory中获取ApplicationListener进行调用。

public interface ApplicationEventMulticaster {

	
	void addApplicationListener(ApplicationListener listener);

	
	void addApplicationListenerBean(String listenerBeanName);

	
	void removeApplicationListener(ApplicationListener listener);

	
	void removeApplicationListenerBean(String listenerBeanName);

	
	void removeAllListeners();

	
	void multicastEvent(ApplicationEvent event);

	
	void multicastEvent(ApplicationEvent event, ResolvableType eventType);

}

在Spring的ApplicationContext的refresh方法中对ApplicationEventMulticaster进行了初始化

@Override
	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();
			}
		}
	}

	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.applicationEventMulticaster + "]");
			}
		}
		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 + "]");
			}
		}
	}

如果我们没有自定义ApplicationEventMulticaster，那么系统就使用默认的SimpleApplicationEventMulticaster。
ApplicationEventPublisher 提供了发送事件的方法，而ApplicationContext继承自此接口，所以我们在应用中通过ApplicationContext#publishEvent方法即可发布事件。

public interface ApplicationEventPublisher {

	
	void publishEvent(ApplicationEvent event);

	
	void publishEvent(Object event);

}

	protected void publishEvent(Object event, ResolvableType eventType) {
		Assert.notNull(event, "Event must not be null");
		if (logger.isTraceEnabled()) {
			logger.trace("Publishing event in " + getDisplayName() + ": " + event);
		}

		// Decorate event as an ApplicationEvent if necessary
		ApplicationEvent applicationEvent;
		if (event instanceof ApplicationEvent) {
			applicationEvent = (ApplicationEvent) event;
		}
		else {
			applicationEvent = new PayloadApplicationEvent