Spring源码解读：Spring的Event编程以及实现原理

---

前言

要想代码写得好，设计模式不可少。
Spring框架启动过程中，有两个设计模式使用较多，一个是观察者模式，一个是processor处理时用的链式模式。今天我们来介绍观察者模式的Event

一、使用

传统方式

咱们写业务代码，经常会涉及到某种业务场景，譬如A的改变，B或者C需要知道，以便改变。
一般程序员写代码可能会写成下面这种

@Service
public class AService {

	@Autowired
	private BService bService;

	@Autowired
	private CService cService;

	public void doSomething() {
		xxxxxx;// A的逻辑
		bService.doSomething();
		cService.doSomething();
	}
}

其实用过微服务的同学大概就发现了，如果A、B、C不是简单的Service，而是三个项目，我们怎么做，类比这上面方法的，A写完自己的逻辑，分别通过RPC的方法调用B和C项目提供的接口。
But，我们是一般的程序员么？？？ of course not~~

观察者模式

观察者模式，那就要分为观察者和被观察者。
先要定义一个观察者关注的对象：

public class SelfEvent{

	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
}

被观察者发送事件代码如下：

@Transactional
@Service
public class MyService {

	@Autowired
	private ApplicationEventPublisher eventPublisher;

	public void publish() {
		SelfEvent selfEvent = new SelfEvent();
		selfEvent.setName("test");
		eventPublisher.publishEvent(selfEvent);
	}
}

观察者对应处理代码如下：
BListener如下

@Service
public class BListener {

	@Autowired
	private BService bService;

	@EventListener(SelfEvent.class)
	public void listenEvent(SelfEvent selfEvent) {
		bService.doSomething();
	}
}

CListener如下

@Service
public class CListener {

	@Autowired
	private CService bService;

	@EventListener(SelfEvent.class)
	public void listenEvent(SelfEvent selfEvent) {
		cService.doSomething();
	}
}

虽然代码量增加了，但是整个功能却解耦了，这样A功能模块和B、C功能模块如果并行开发，只需要定义好Event的数据结构即可。
而且如果类比的话，看起来是不是很像是MQ的效果，不过这三个功能模块属于一个项目，默认同步处理的话，还属于一个事务，除了代码量增加了，其他全是好处。

二、源码解读

AbstractApplicationContext#publishEvent

看到这个方法的类，是不是觉得有一丝惊讶？ApplicationEventPublisher的方法具体实现居然是在AbstractApplicationContext里，看看类结构，就能发现怎么回事了，ApplicationContext接口继承了ApplicationEventPublisher接口。
这样一看，spring的容器（ApplicationContext）真是个大而全的家伙
非重点代码都忽略不展示

/**
	 * Publish the given event to all listeners.
	 * @param event the event to publish (may be an {@link ApplicationEvent}
	 * or a payload object to be turned into a {@link PayloadApplicationEvent})
	 * @param eventType the resolved event type, if known
	 */
	protected void publishEvent(Object event, @Nullable ResolvableType eventType) {

		// Decorate event as an ApplicationEvent if necessary
		ApplicationEvent applicationEvent;
		// do something 
		// 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);
			}
		}
	}

getApplicationEventMulticaster()默认拿到的是初始化配置的SimpleApplicationEventMulticaster，来看看它的multicastEvent方法

SimpleApplicationEventMulticaster#multicastEvent

@Override
	public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
		ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
		// 此处默认是null
		Executor executor = getTaskExecutor();
		for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {
			if (executor != null) {
				executor.execute(() -> invokeListener(listener, event));
			}
			else {
				invokeListener(listener, event);
			}
		}
	}

此处先简单说明下getApplicationListeners(event, type)的逻辑

找到监听了publishEvent中event类型的所有加了@EventListener的方法，
并同时缓存起来，防止下次publish同一种event

这个Listener其实就是封装了加了@EventListener注解的方法的各个属性，这样，调用invokeListener时，其实就是通过反射调用了方法。

listeners加载的逻辑

不知道大家有没有看过我的这篇文章，这篇文章是讲Spring容器初始化，同时容器里的reader做的事儿来着，reader往容器中添加了几个容器初始化必须的类，最后一个是DefaultEventListenerFactory，也就是咱们默认的事件监听器工厂。倒数第二个是EventListenerMethodProcessor，是咱们的事件监听方法处理器。

这个工厂做了一件重要的事儿，调用链是：
1. 在DefaultListableBeanFactory#preInstantiateSingletons（spring中bean的实例化方法）最后调用了SmartInitializingSingleton#afterSingletonsInstantiated；
2. 因此调用了EventListenerMethodProcessor#afterSingletonsInstantiated；
3. 因此调用了EventListenerMethodProcessor#processBean；

也就是说spring的bean实例化完之后，就通过EventListenerMethodProcessor把所有添加了@EventListener注解的方法包装成了ApplicationListenerMethodAdapter。（至此spring容器初始化放入的5个重要类全都清晰了）
下面这段代码截取自EventListenerMethodProcessor#processBean

annotatedMethods = MethodIntrospector.selectMethods(targetType,
						(MethodIntrospector.MetadataLookup<EventListener>) method ->
								AnnotatedElementUtils.findMergedAnnotation(method, EventListener.class));

// 。。。。。 do something


//此处获取的就是DefaultEventListenerFactory
List<EventListenerFactory> factories = this.eventListenerFactories;
for (Method method : annotatedMethods.keySet()) {
	for (EventListenerFactory factory : factories) {
		if (factory.supportsMethod(method)) {
			Method methodToUse = AopUtils.selectInvocableMethod(method, context.getType(beanName));
			ApplicationListener<?> applicationListener =
					factory.createApplicationListener(beanName, targetType, methodToUse);
			if (applicationListener instanceof ApplicationListenerMethodAdapter) {
				((ApplicationListenerMethodAdapter) applicationListener).init(context, this.evaluator);
			}
			context.addApplicationListener(applicationListener);
			break;
		}
	}
}

可以看到这个方法做的事儿，就是把当前对象类中所有加了@EventListener注解的方法全都找出来，同时基于给每个方法实例化一个ApplicationListenerMethodAdapter，并放入到咱们的容器中，直到publishEvent时，遍历出符合条件的listener，然后反射进行实现。

三、改成异步

在spring容器refresh操作时，也就是AbstractApplicationContext#refresh时，会调用initApplicationEventMulticaster，进行事件多发器的初始化

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);
		}
		else {
			this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
			beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
		}
	}

可以看到主要逻辑就是判断容器里面有没有事件多发器，如果没有，就new了一个SimpleApplicationEventMulticaster，但是没有setExecutor，所以在publishEvent执行的时候，没有executor可以使用，只能同步执行。
那么简单了，咱们自己来往容器里放一个

	@Bean("applicationEventMulticaster")
	public SimpleApplicationEventMulticaster applicationEventMulticaster() {
		SimpleApplicationEventMulticaster applicationEventMulticaster = new SimpleApplicationEventMulticaster();
		// 具体线程池的初始化方式，可以根据自己需要进行修改
		Executor taskExecutor = Executors.newFixedThreadPool(5);
		applicationEventMulticaster.setTaskExecutor(taskExecutor);
		return applicationEventMulticaster;
	}

这样，咱们自己设置的事件多发器便有了executor，那么publish的event就可以通过线程池异步执行了，不过因此失去了事务。所以具体是否需要使用异步，由用户自己确定。

总结

以上就是今天要讲的内容，Spring的Event，逻辑不复杂，代码写起来也解耦。nice~，拓展一下思路，这就是个进程内部的MQ呀