【Spring】事件监听实现原理（十）

一、事件监听介绍

　　原理: 观察者模式　　

　　spring的事件监听有三个部分组成:

• 事件(ApplicationEvent) 负责对应相应监听器 事件源发生某事件是特定事件监听器被触发的原因。

• 监听器(ApplicationListener) 对应于观察者模式中的观察者。监听器监听特定事件,并在内部定义了事件发生后的响应逻辑。

• 事件发布器(ApplicationEventMulticaster )对应于观察者模式中的被观察者/主题， 负责通知观察者 对外提供发布事件和增删事件监听器的接口,维护事件和事件监听 器之间的映射关系,并在事件发生时负责通知相关监听器。

　　

二、事件监听使用

1、事件

public class MyApplicationEvent extends ApplicationEvent {

    private String msg;

    public MyApplicationEvent(Object source) {
        super(source);
    }

    public MyApplicationEvent(Object source, String msg) {
        super(source);
        this.msg = msg;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }
}

2、监听器-接口模式

@Component
public class MyApplicationListener implements ApplicationListener {
    @Override
    public void onApplicationEvent(ApplicationEvent event) {
        System.out.println("MyApplicationListener: " +  "正在处理器事件");
        System.out.println("MyApplicationListener-事件源：" + event.getSource());
        if(event instanceof MyApplicationEvent) {
            System.out.println("MyApplicationListener-事件msg：" + ((MyApplicationEvent) event).getMsg());
        }
    }
}

　　监听器-注解模式

@Component
public class MyCustomListener {

    @EventListener
    public void processEvent(ApplicationEvent event){
        System.out.println("MyCustomListener: " +  "正在处理器事件");
        System.out.println("MyCustomListener-事件源：" + event.getSource());
        if(event instanceof MyApplicationEvent) {
            System.out.println("MyCustomListener-事件msg：" + ((MyApplicationEvent) event).getMsg());
        }
    }

}

3、事件发布器，使用Spring内置的，配置类

@Configuration
@ComponentScan("com.test.listener.component")
public class MainConfig {
    public MainConfig(){
        System.out.println("MainConfig 构造方法");
    }
} 

 4、主方法启动

public class MainStarter {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfig.class);
        // 1、创建一个事件
        MyApplicationEvent myApplicationEvent = new MyApplicationEvent(new Object(), "这是一个的新事件");
        // 2、发布事件
        context.publishEvent(myApplicationEvent);
        // 3、监听器处理
        // .....
        context.close();
    }

} 

 三、原理图

1、事件监听相关类图

　　

2、执行流程图

　　

四、Spring事件监听源码分析

 1、在reflush()，方法中调用 initApplicationEventMulticaster() 初始化事件广播器

protected void initApplicationEventMulticaster() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    // 判断Bean工厂中是有没有applicationEventMulticaster 应用广播器组件
    if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
        // 直接显示的调用getBean获取出来赋值给的applicationContext对象
        this.applicationEventMulticaster =
                beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
        if (logger.isTraceEnabled()) {
            logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
        }
    }
    // Bean工厂中没有的话
    else {
        // new 一个SimpleApplicationEventMulticaster对象
        this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
        // 并且注入到容器中
        beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
        if (logger.isTraceEnabled()) {
            logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +
                    "[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
        }
    }
}

2、在reflush()，方法中调用registerListeners() 注册监听器

protected void registerListeners() {
    // Register statically specified listeners first.
    // 获取容器中所有的监听器对象(成品对象)
    for (ApplicationListener<?> listener : getApplicationListeners()) {
        // 把监听器的注册到事件广播器上去
        getApplicationEventMulticaster().addApplicationListener(listener);
    }

    // Do not initialize FactoryBeans here: We need to leave all regular beans
    // uninitialized to let post-processors apply to them!
    // 根据类型从bean工厂的bean定义中，获取bean定义名单
    String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
    for (String listenerBeanName : listenerBeanNames) {
        // 把监听器的注册到事件广播器上去，只是注册的名单
        getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
    }

    // Publish early application events now that we finally have a multicaster...
    // 获取早期事件
    Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
    this.earlyApplicationEvents = null;
    if (earlyEventsToProcess != null) {
        for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
            // 获取事件广播器，发布早期事件
            getApplicationEventMulticaster().multicastEvent(earlyEvent);
        }
    }
} 

 3、发布事件方法  publishEvent()

protected void publishEvent(Object event, @Nullable ResolvableType eventType) {
    Assert.notNull(event, "Event must not be null");

    // Decorate event as an ApplicationEvent if necessary
    // 1、如有必要，将事件装饰为ApplicationEvent
    ApplicationEvent applicationEvent;
    if (event instanceof ApplicationEvent) {
        applicationEvent = (ApplicationEvent) event;
    }
    else {
        applicationEvent = new PayloadApplicationEvent<>(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) {
        this.earlyApplicationEvents.add(applicationEvent);
    }
    else {
        //  2、使用事件广播器广播事件到相应的监听器
        getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
    }

    // Publish event via parent context as well...
    // 3、如果有父容器
    if (this.parent != null) {
        if (this.parent instanceof AbstractApplicationContext) {
            // 使用父容器，带事件类型参数的，    发布事件
            ((AbstractApplicationContext) this.parent).publishEvent(event, eventType);
        }
        else {
            // 使用父容器发布事件
            this.parent.publishEvent(event);
        }
    }
} 

 4、广播器广播事件方法 multicastEvent()

@Override
public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
    ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
    // 1、返回此广播器的当前任务执行器
    Executor executor = getTaskExecutor();
    // 2、、getApplicationListeners:返回与给定事件类型匹配的应用监听器集合
    for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {
        // 3.1 executor不为null，则使用executor调用监听器
        if (executor != null) {
            executor.execute(() -> invokeListener(listener, event));
        }
        // 3.2 否则，直接调用监听器
        else {
            invokeListener(listener, event);
        }
    }
} 

  5、广播器广播事件方法 multicastEvent() , 其中 doInvokeListener() 就去调用了监听器的处理事件方法

protected void invokeListener(ApplicationListener<?> listener, ApplicationEvent event) {
    // 1.返回此广播器的当前错误处理器
    ErrorHandler errorHandler = getErrorHandler();
    if (errorHandler != null) {
        try {
            // 2.1 如果errorHandler不为null，则使用带错误处理的方式调用给定的监听器
            doInvokeListener(listener, event);
        }
        catch (Throwable err) {
            errorHandler.handleError(err);
        }
    }
    else {
        // 2.2 否则，直接调用调用给定的监听器
        doInvokeListener(listener, event);
    }
}