标签：
一、代码实例
回到第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 //自定义广播
[spring源码学习]九、IOC源码-applicationEventMulticaster事件广播
标签：
原文地址：http://www.cnblogs.com/jyyzzjl/p/5476546.html
