publishEvent->multicastEvent()解析 使用场景

使用场景：

  1、异步处理，比如订单完成后想异步发送消息

  2、事件告知，比如想知道spring容器是否启动完成，那么就可以监听spring启动完成后的事件

  3、扩展处理，比如监听 跑完步 这个事件，接着会喝水。考虑到后面可能跑完步还要去吃饭，那么可以通过监听同一个事件来完成。

省的还需要改原来的代码。代码也解耦了。

       4、模块解耦，减少模块之间的依赖。解耦维度是模块

 

    
//推送事件到响应的监听器
    protected void publishEvent(Object event, @Nullable ResolvableType eventType) {
        Assert.notNull(event, "Event must not be null");

        // Decorate event as an ApplicationEvent if necessary
        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 {
        //使用事件广播器广播事件到对应的监听器
            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);
            }
        }
    }


        @Override
    public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
        ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
        Executor executor = getTaskExecutor();
        // getApplicationListeners(event, type)返回与给定事件类型匹配的应用监听器集合
        //实现监听事件，实现ApplicationListener接口就行    
        //自定义监听事件，继承ApplicationContextEvent，通过ApplicationEventPublisher发布就行
        for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {
            if (executor != null) {
                executor.execute(() -> invokeListener(listener, event));
            }
            else {
                invokeListener(listener, event);
            }
        }
    }



        private void doInvokeListener(ApplicationListener listener, ApplicationEvent event) {
        try {
        //触发监听器的onApplicationEvent，入参为给定的事件
            listener.onApplicationEvent(event);
        }
        catch (ClassCastException ex) {
            String msg = ex.getMessage();
            if (msg == null || matchesClassCastMessage(msg, event.getClass())) {
                // Possibly a lambda-defined listener which we could not resolve the generic event type for
                // -> let's suppress the exception and just log a debug message.
                Log logger = LogFactory.getLog(getClass());
                if (logger.isTraceEnabled()) {
                    logger.trace("Non-matching event type for listener: " + listener, ex);
                }
            }
            else {
                throw ex;
            }
        }
    }