Springboot中AbstractApplicationEventMulticaster有什么作用

本篇内容介绍了“Springboot中AbstractApplicationEventMulticaster有什么作用”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！

专注于为中小企业提供网站建设、网站设计服务,电脑端+手机端+微信端的三站合一,更高效的管理,为中小企业彝良免费做网站提供优质的服务。我们立足成都，凝聚了一批互联网行业人才，有力地推动了上千企业的稳健成长，帮助中小企业通过网站建设实现规模扩充和转变。

    Springboot的版本2.0.9.release，对应的SpringFramework值5.0.x.release。

    AbstractApplicationEventMulticaster并不是Springboot里面的，而是属于SpringFramework的。

                                                                                      图1

    如上图1所示，AbstractApplicationEventMulticaster继承了BeanFactoryAware，用于获取BeanFactory；ApplicationEventMulticaster则包含增加、删除ApplicationListener的接口方法，支持对象和String类型的bean名称。

    一开始以为AbstractApplicationEventMulticaster应该有个List的属性用于存放加入其中的ApplicationListener，但是看了源码之后，发现Spring考虑的更周全、考虑的情况更多。

    List-1

public abstract class AbstractApplicationEventMulticaster implements ApplicationEventMulticaster, BeanClassLoaderAware, BeanFactoryAware {
    private final AbstractApplicationEventMulticaster.ListenerRetriever defaultRetriever = new AbstractApplicationEventMulticaster.ListenerRetriever(false);
    final Map retrieverCache = new ConcurrentHashMap(64);
    @Nullable
    private ClassLoader beanClassLoader;
    @Nullable
    private BeanFactory beanFactory;
    private Object retrievalMutex;

...
private class ListenerRetriever {
    public final Set> applicationListeners = new LinkedHashSet();
    public final Set applicationListenerBeans = new LinkedHashSet();
    private final boolean preFiltered;

    public ListenerRetriever(boolean preFiltered) {
        this.preFiltered = preFiltered;
    }
...

    如上的List-1，ListenerRetriever中的LinkedHashSet，才是真正存放ApplicationListener的地方。而retrieverCache则是用于作为缓存，为什么要做缓存，是因为我们丢给AbstractApplicationEventMulticaster的Event不一定会被发送，只有找到能支持这种Event的ApplicationListener才会进行发送。

    首先来看下addApplicationListener，如下List-2，如果是ApplicationListener的实例，则加入到defaultRetriever的Set中，如果是String类型的beanName，则加入到defaultRetriever的applicationListenerBeans中，最后都调用retrieverCache的clear方法，retrieverCache是个线程安全的Map，因为新加入了ApplicationListener，所以我们需要更新我们的缓存。

    List-2

public void addApplicationListener(ApplicationListener listener) {
    synchronized(this.retrievalMutex) {
        Object singletonTarget = AopProxyUtils.getSingletonTarget(listener);
        if (singletonTarget instanceof ApplicationListener) {
            this.defaultRetriever.applicationListeners.remove(singletonTarget);
        }

        this.defaultRetriever.applicationListeners.add(listener);
        this.retrieverCache.clear();
    }
}

public void addApplicationListenerBean(String listenerBeanName) {
    synchronized(this.retrievalMutex) {
        this.defaultRetriever.applicationListenerBeans.add(listenerBeanName);
        this.retrieverCache.clear();
    }
}
...

    来看retrieveApplicationListeners方法的实现，这个很重要，因为发送Event之前，会先检索出支持这种event的ApplicationListener。如下所示List-3:

1. 遍历applicationListeners，调用supportsEvent方法，如果支持，加将当前的ApplicationListener加入到结果集中。

2. 之后遍历applicationListenerBeans，先从BeanFactory中获取对应的ApplicationListener实例，如果BeanFactory中含有对应的ApplicationListener，且supportsEvent方法返回true，那么将当前的ApplicationListener加入到结果集中。

3. 最后调用AnnotationAwareOrderComparator进行排序。

    List-3

private Collection> retrieveApplicationListeners(ResolvableType eventType, @Nullable Class sourceType, @Nullable AbstractApplicationEventMulticaster.ListenerRetriever retriever) {
    List> allListeners = new ArrayList();
    LinkedHashSet listeners;
    LinkedHashSet listenerBeans;
    synchronized(this.retrievalMutex) {
        listeners = new LinkedHashSet(this.defaultRetriever.applicationListeners);
        listenerBeans = new LinkedHashSet(this.defaultRetriever.applicationListenerBeans);
    }
    Iterator var7 = listeners.iterator();
    while(var7.hasNext()) {
        ApplicationListener listener = (ApplicationListener)var7.next();
        if (this.supportsEvent(listener, eventType, sourceType)) {
            if (retriever != null) {
                retriever.applicationListeners.add(listener);
            }
            allListeners.add(listener);
        }
    }

    if (!listenerBeans.isEmpty()) {
        BeanFactory beanFactory = this.getBeanFactory();
        Iterator var15 = listenerBeans.iterator();
        while(var15.hasNext()) {
            String listenerBeanName = (String)var15.next();
            try {
                Class listenerType = beanFactory.getType(listenerBeanName);
                if (listenerType == null || this.supportsEvent(listenerType, eventType)) {
                    ApplicationListener listener = (ApplicationListener)beanFactory.getBean(listenerBeanName, ApplicationListener.class);
                    if (!allListeners.contains(listener) && this.supportsEvent(listener, eventType, sourceType)) {
                        if (retriever != null) {
                            retriever.applicationListenerBeans.add(listenerBeanName);
                        }
                        allListeners.add(listener);
                    }
                }
            } catch (NoSuchBeanDefinitionException var13) {
            }
        }
    }

    AnnotationAwareOrderComparator.sort(allListeners);
    return allListeners;
}

    AbstractApplicationEventMulticaster的子类，需要实现multicastEvent方法，我们来看下SimpleApplicationEventMulticaster是如何实现的。

    如下List-4所示，默认情况下taskExecutor是null。

    multicastEvent方法中调用父类的getApplicationListeners方法获取支持Event的ApplicationListener，之后遍历ApplicationListener，如果taskExecutor不是null，则交给Executor；否则逐个调用ApplicationListener的onApplicationEvent方法。

    List-4

public class SimpleApplicationEventMulticaster extends AbstractApplicationEventMulticaster {
    @Nullable
    private Executor taskExecutor;

    public void multicastEvent(ApplicationEvent event, @Nullable ResolvableType eventType) {
        ResolvableType type = eventType != null ? eventType : this.resolveDefaultEventType(event);
        Iterator var4 = this.getApplicationListeners(event, type).iterator();
        while(var4.hasNext()) {
            ApplicationListener listener = (ApplicationListener)var4.next();
            Executor executor = this.getTaskExecutor();
            if (executor != null) {
                executor.execute(() -> {
                    this.invokeListener(listener, event);
                });
            } else {
                this.invokeListener(listener, event);
            }
        }
    }

    private void doInvokeListener(ApplicationListener listener, ApplicationEvent event) {
        try {
            listener.onApplicationEvent(event);
        } catch (ClassCastException var6) {
            String msg = var6.getMessage();
            if (msg != null && !this.matchesClassCastMessage(msg, event.getClass())) {
                throw var6;
            }
        }
    }
...

    Springboot中SpringApplicationRunListener的默认实现有个EventPublishingRunListener，如下List-5所示

    List-5

public class EventPublishingRunListener implements SpringApplicationRunListener, Ordered {
	private final SimpleApplicationEventMulticaster initialMulticaster;
    ...
	@Override
	public void starting() {
		this.initialMulticaster.multicastEvent(
				new ApplicationStartingEvent(this.application, this.args));
	}

	@Override
	public void environmentPrepared(ConfigurableEnvironment environment) {
		this.initialMulticaster.multicastEvent(new ApplicationEnvironmentPreparedEvent(
				this.application, this.args, environment));
	}
    ...
	@Override
	public void started(ConfigurableApplicationContext context) {
		context.publishEvent(
				new ApplicationStartedEvent(this.application, this.args, context));
	}
    ...

    如List-5中所示，Springboot启动的不同阶段，会传不同的event实现给EventPublishingRunListener，而EventPublishingRunListener则用Delete委托模式，交给initialMulticaster去处理。当然，started、running、failed事件则交给ConfigurableApplicationContext去处理。

    来看EventPublishingRunListener的构造方法如下List-6所示，从SpringApplication中获取Listener，之后加入到SimpleApplicationEventMulticaster中，所以Springboot中的事件是先交给SpringApplicationRunListener，之后SpringApplicationRunListener再委托给ApplicationListener的实现类完成具体的。

    List-6

public class EventPublishingRunListener implements SpringApplicationRunListener, Ordered {
	private final SpringApplication application;
	private final SimpleApplicationEventMulticaster initialMulticaster;
    ...
	public EventPublishingRunListener(SpringApplication application, String[] args) {
		this.application = application;
		this.args = args;
		this.initialMulticaster = new SimpleApplicationEventMulticaster();
		for (ApplicationListener listener : application.getListeners()) {
			this.initialMulticaster.addApplicationListener(listener);
		}
	}
	...

    ApplicationListener的实现类如下图2

                                                                                     图2

“Springboot中AbstractApplicationEventMulticaster有什么作用”的内容就介绍到这里了，感谢大家的阅读。如果想了解更多行业相关的知识可以关注创新互联网站，小编将为大家输出更多高质量的实用文章！