Spring事件机制

总结：

事件广播器ApplicationEventMulticaster中维护者所有的监听器ApplicationListener，当事件发布器ApplicationEventPublisher发布一个事件ApplicationEvent到事件广播器中，事件广播器会遍历所有符合事件类型的事件监听器，对事件进行消费监听；

默认事项发布是一个同步的操作,也可以设置为异步。查看@同步异步

职能分划

a、ApplicationListener：事件监听器
ApplicationListener是观察者，可以通过实现接口或者注解来自定义观察者，ApplicationListener会感受到某种状态变化。ApplicationListener 继承自 JDK 的 EventListener ，JDK 要求所有监听者继承它。监听者只有一个方法 onApplicationEvent，用来处理事件 ApplicationEvent。
项目中我们自己自定义观察者（监听者）对象；

@Component
public class ProjectEventListener implements ApplicationListener<WLkEvent> {

  

    @Override
    public void onApplicationEvent(WLkEvent wLkEvent) {
        eventsProcess(wLkEvent);
    }
}

b、ApplicationEvent：事件
ApplicationEvent是事件对象，是事件传达到介质。在事件中，被观察者可以认为是发出事件到那一方，只有在状态变化时才发布事件。ApplicationEvent是一个抽象类，继承类EventObject类
项目中我们自定义事项对象

public class WLkEvent extends ApplicationEvent{

    private static final long serialVersionUID = 6701614314920216157L;
    private String sourceId;
    public WLkEvent (Object source,Long sourceId) {
        super(source);
        this.sourceId=sourceId;
    }
}

c、ApplicationEventPublisher：事件发布器
通过publishEvent发布一个事件，spring通过广播把事件传递给所有到观察者。调用观察者到onApplicationEvent()把事件对象传递给观察者。所有的容器对象基本都实现了ApplicationEventPublisher

项目中将事项发布出去：

 @Autowired
    private ApplicationContext applicationContext;
    
//发布事件
//ApplicationEventPublisher会将事件发布给事件广播器ApplicationEventMulticaster，事件广播器里保存着所有的事件监听器，依次让符合事件类型的事项监听器对事件进行监听
        applicationContext.publishEvent(new WLkEvent (applicationContext,id));

d、ApplicationEventMulticaster：事件广播器
框架提供了 ApplicationEventMulticaster 接口的默认实现 SimpleApplicationEventMulticaster，如果本地容器中没有 ApplicationEventMulticaster 的实现就会使用这个默认实现。

//可以通过观察者添加/移除/发布，也可以通过观察者名称，通过名称可以在容器中拿到观察者对实体，
public interface ApplicationEventMulticaster {
    //增加观察者
    void addApplicationListener(ApplicationListener<?> var1);
    void addApplicationListenerBean(String var1);
    //移除观察者
    void removeApplicationListener(ApplicationListener<?> var1);
    void removeApplicationListenerBean(String var1);
    void removeAllListeners();
    //发布观察者
    void multicastEvent(ApplicationEvent var1);
    void multicastEvent(ApplicationEvent var1, ResolvableType var2);
}

在 SimpleApplicationEventMulticaster 中，可以看到 multicastEvent 方法中遍历了所有的 Listener，并依次调用 Listener 的 onApplicationEvent 方法发布事件。@同步异步：Spring 还提供了异步发布事件的能力，taskExecutor 不为 null 时即异步执行。

public class SimpleApplicationEventMulticaster extends AbstractApplicationEventMulticaster {
    @Nullable
    private Executor taskExecutor;
    public void setTaskExecutor(Executor taskExecutor) { this.taskExecutor = taskExecutor;}
    protected Executor getTaskExecutor() {return this.taskExecutor;}
    //...
    //发布观察者
    @Override
    public void multicastEvent(final ApplicationEvent event, ResolvableType eventType) {
        ResolvableType type = eventType != null ? 
            eventType : 
            this.resolveDefaultEventType(event);
        //拿到所有event来源并且eventType类型对观察者
        Iterator var4 = this.getApplicationListeners(event, type).iterator();
        while(var4.hasNext()) {
            //获取当前观察者
            final ApplicationListener<?> listener = (ApplicationListener)var4.next();
            Executor executor = this.getTaskExecutor();
            //taskExecutor不为null时，执行异步发布事件
            if (executor != null) {
                executor.execute(new Runnable() {
                    public void run() {
                        SimpleApplicationEventMulticaster.this.invokeListener(listener, event);
                    }
                });
            } else {
                this.invokeListener(listener, event);
            }
        }
    }
    
    //检查错误处理类
    protected void invokeListener(ApplicationListener<?> listener, ApplicationEvent event) {
        ErrorHandler errorHandler = this.getErrorHandler();
        //错误处理类不为空时，捕获执行异常，有异常时执行处理类对自定义方法
        if (errorHandler != null) {
            try {
                this.doInvokeListener(listener, event);
            } catch (Throwable var5) {
                errorHandler.handleError(var5);
            }
        } else {
            this.doInvokeListener(listener, event);
        }

    }
    
    //执行观察者onApplicationEvent方法
    private void doInvokeListener(ApplicationListener listener, ApplicationEvent event) {
		try {
			listener.onApplicationEvent(event);
		}
		catch (ClassCastException ex) {
			//省略类异常处理
		}
	}
    //...
}