一、代码实例
回到第IOC的第七章context部分，我们看源码分析部分，可以看到在spring的bean加载之后的第二个重要的bean为applicationEventMulticaster，从字面上我们知道它是一个事件广播器。在第8和9部分，详细描述了广播器的初始化：
1、查找是否有name为applicationEventMulticaster的bean，如果有放到容器里，如果没有，初始化一个系统默认的放入容器
2、查找手动设置的applicationListeners，添加到applicationEventMulticaster里
3、查找定义的类型为ApplicationListener的bean，设置到applicationEventMulticaster
4、初始化完成、对earlyApplicationEvents里的事件进行通知（此容器仅仅是广播器未建立的时候保存通知信息，一旦容器建立完成，以后均直接通知）
5、在系统操作时候，遇到的各种bean的通知事件进行通知
以上流程我们在第七章源码部分都已经分析过了，所以不再赘述。可以看到的是applicationEventMulticaster是一个标准的观察者模式，对于他内部的监听者applicationListeners，每次事件到来都会一一获取通知。
我们来进行实例展示：
1、定义一个ApplicationEvent，
package com.zjl;
import org.springframework.context.ApplicationEvent;
public class MyApplicationEvent extends ApplicationEvent {
/**
*
*/
private static final long serialVersionUID = 1L;
public MyApplicationEvent(Object source) {
super(source);
}
}
2、定义一个事件处理器MyApplicationListener，仅仅监听我们自定义的事件，注：此处的泛型如果不指定或者指定ApplicationEvent，可以监听所有spring发出的监听
package com.zjl;
import org.springframework.context.ApplicationListener;
public class MyApplicationListener implements ApplicationListener<MyApplicationEvent> {
@Override
public void onApplicationEvent(MyApplicationEvent event) {
System.out.println(event.getSource()+"==== "+event.getTimestamp());
}
}
3、测试代码
public class Test {
public static void main(String[] args) {
ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("bean.xml");
context.publishEvent(new MyApplicationEvent("init-bean"));
Person person=(Person)context.getBean("person");
person.sayHello();
}
}
4、结果（成功的打印出事件的内容）
init-bean==== 1462785633657
hello zhangsan
二、源码分析
1、执行publishEvent，支持两种事件1、直接继承ApplicationEvent，2、其他时间，会被包装为PayloadApplicationEvent，可以使用getPayload获取真实的通知内容
如果广播器未生成，先存起来，已经生成的调用multicastEvent进行发送
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;
//支持两种事件1、直接继承ApplicationEvent，2、其他时间，会被包装为PayloadApplicationEvent，可以使用getPayload获取真实的通知内容
if (event instanceof ApplicationEvent) {
applicationEvent = (ApplicationEvent) event;
}
else {
applicationEvent = new PayloadApplicationEvent<Object>(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) {
//如果有预制行添加到预制行，预制行在执行一次后被置为null，以后都是直接执行
this.earlyApplicationEvents.add(applicationEvent);
}
else {
//广播event时间
getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
}
// Publish event via parent context as well...
//父bean同样广播
if (this.parent != null) {
if (this.parent instanceof AbstractApplicationContext) {
((AbstractApplicationContext) this.parent).publishEvent(event, eventType);
}
else {
this.parent.publishEvent(event);
}
}
}
2、查找所有的监听者，依次遍历，如果有线程池，利用线程池进行发送，如果没有则直接发送，如果针对比较大的并发量，我们应该采用线程池模式，将发送通知和真正的业务逻辑进行分离
public void multicastEvent(final ApplicationEvent event, ResolvableType eventType) {
ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
for (final ApplicationListener<?> listener : getApplicationListeners(event, type)) {
Executor executor = getTaskExecutor();
if (executor != null) {
executor.execute(new Runnable() {
@Override
public void run() {
invokeListener(listener, event);
}
});
}
else {
invokeListener(listener, event);
}
}
}
3、在获取监听器的过程中调用,，可以看到监听器根据两种类型判断是否需要处理：
a)、继承SmartApplicationListener的情况下，根据supportsEventType返回结果判断
b)、根据监听器的泛型判断（示例采用第二种方式），比较泛型的代码很复杂，暂时就不关心了
public boolean supportsEventType(ResolvableType eventType) {
//判断监听器是否可以监听事件有两种方式：
//1、如果监听器是SmartApplicationListener的实现，那么会重写supportsEventType，返回true就是支持
if (this.delegate instanceof SmartApplicationListener) {
Class<? extends ApplicationEvent> eventClass = (Class<? extends ApplicationEvent>) eventType.getRawClass();
return ((SmartApplicationListener) this.delegate).supportsEventType(eventClass);
}
else {
//根据泛型内容与事件类型是否一致
return (this.declaredEventType == null || this.declaredEventType.isAssignableFrom(eventType));
}
}
3、调用invokeListener，如果有errorHandler会有errorHandler处理异常
protected void invokeListener(ApplicationListener listener, ApplicationEvent event) {
ErrorHandler errorHandler = getErrorHandler();
if (errorHandler != null) {
try {
listener.onApplicationEvent(event);
}
catch (Throwable err) {
errorHandler.handleError(err);
}
}
else {
try {
listener.onApplicationEvent(event);
}
catch (ClassCastException ex) {
// Possibly a lambda-defined listener which we could not resolve the generic event type for
LogFactory.getLog(getClass()).debug("Non-matching event type for listener: " + listener, ex);
}
}
}
4、到此为止，我们完成了广播器的代码跟踪
三、总结
广播器的代码不算复杂，使用了一个标准的观察者模式，系统在初始化的时候会在context中注册一个applicationListeners，如果系统有需要广播的情况下，会发送一个applicationEvent事件，注册的listener会根据自己关心的类型进行接收和解析。
在我们之前的实力中，我们需要补充的主要有三点：
1、监听器对于事件的处理，系统中有两种方式：
a)、继承SmartApplicationListener的情况下，根据supportsEventType返回结果判断
b)、根据监听器的泛型判断
c)、我们很容易想到，如果没有继承父类，也没有泛型的情况下，我们可以在广播器的onApplicationEvent方法中获取到event，然后自行过滤
2、事件通知往往是独立于整个程序运行之外的一个补充，所以另外开启线程进行工作是个不错的办法，listener中提供了executor的注入来实现多线程
3、事件的类型不仅仅支持ApplicationEvent类型，也支持其他类型，spring会自动转化为PayloadApplicationEvent，我们调用它的getPayload将获取到具体的数据
4、可以注入一个errorHandler，完成对异常的处理
四、示例修改
1、修改配置文件
<bean name="MyApplicationListener" class="com.zjl.MyApplicationListener">
</bean>
<!-- 定义一个固定大小的线程，采用factory-method和静态方法的形式，参数注入使用构造函数注入 -->
<bean name="executor" class="java.util.concurrent.Executors" factory-method="newFixedThreadPool">
<constructor-arg index="0"><value>5</value></constructor-arg>
</bean>
<!-- 定义applicationEventMulticaster，注入线程池和errorHandler,此处使用系统自带的广播器，也可以注入其他广播器， -->
<bean name="applicationEventMulticaster" class="org.springframework.context.event.SimpleApplicationEventMulticaster">
<property name="taskExecutor" ref="executor"></property>
<property name="errorHandler" ref="errorHandler"></property>
</bean>
<!-- 定义一个errorHandler，统一处理异常信息 -->
<bean name="errorHandler" class="com.zjl.MyErrorHandler"></bean>
2、异常处理的errorHandler
public class MyErrorHandler implements ErrorHandler {
@Override
public void handleError(Throwable t) {
System.out.println("捕获到了异常："+t.getMessage());
}
}
3、修改MyApplicationListener ，使它继承SmartApplicationListener，主要做以下处理：
a)supportsSourceType-判断广播来源类的类型，全部返回true，表示接收所有类的广播
b)supportsEventType-接收PayloadApplicationEvent类型，也就是非event类型的广播；自定义的广播
c)为了使errorHandler起作用，用了一个1/0，使系统抛出一个异常，注：此处由于onApplicationEvent本身接口没有抛出异常，所以显式的异常系统编译都会有问题，所以感觉并不好用
public class MyApplicationListener implements SmartApplicationListener{
@Override
public void onApplicationEvent(ApplicationEvent event){
System.out.println(Thread.currentThread().getName()+"-"+event.getSource()+"===="+event.getTimestamp());
if(event.getSource().equals("person-sayhello")){
int num=1/0;
}
}
@Override
public int getOrder() {
return 0;
}
@Override
public boolean supportsEventType(Class<? extends ApplicationEvent> eventType){
if(PayloadApplicationEvent.class.isAssignableFrom(eventType)){
System.out.println("非ApplicationEvent的广播");
return true;
}else if(MyApplicationEvent.class.isAssignableFrom(eventType)) {
System.out.println("自定义广播");
return true;
}
return false;
}
@Override
public boolean supportsSourceType(Class<?> sourceType) {
System.out.println("sourceType====="+sourceType);
return true;
}
}
4、bean内容，因为在bean中发出广播，需要使用context，此处直接使用ApplicationContextAware接口形式注入bean
public class Person implements ApplicationContextAware {
private ApplicationContext applicationContext;
private String name;
public boolean running;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void sayHello(){
applicationContext.publishEvent(new MyApplicationEvent("person-sayhello"));
System.out.println("hello "+this.name);
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
this.applicationContext=applicationContext;
}
}
5、测试程序
public class Test {
public static void main(String[] args) {
ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("bean.xml");
context.publishEvent("init-bean");
Person person=(Person)context.getBean("person");
person.sayHello();
}
}
6、运行结果我们可以看到不同的广播按照规则进行了过滤，而且最终是使用不同的线程进行发送。如果有异常，errorHandler顺利捕捉到了异常。那么这个例子基本涵盖了广播的所有点。
非ApplicationEvent的广播 //非系统广播自定义广播可以通过
sourceType=====class org.springframework.context.support.ClassPathXmlApplicationContext //来自context的广播可以通过
自定义广播 //自定义广播可以通过
sourceType=====class java.lang.String //来自主程序的广播可以通过
hello zhangsan
pool-1-thread-2-person-sayhello====1462862846700 //非event广播内容
捕获到了异常：/ by zero//异常
pool-1-thread-1-org.springframework.context.support.ClassPathXmlApplicationContext@48503868: startup date [Tue May 10 14:47:25 CST 2016]; root of context hierarchy====1462862846699 //自定义广播