AbstractApplicationEventMulticaster学习

简介

AbstractApplicationEventMulticaster 是 Spring 框架中的一个抽象类，它实现了 ApplicationEventMulticaster 接口，并为事件广播提供了基本的实现。这个类是一个中间层，它定义了一些通用的行为，同时允许子类进行扩展和定制。SimpleApplicationEventMulticaster 类就是 AbstractApplicationEventMulticaster 的一个具体实现。

AbstractApplicationEventMulticaster 的主要功能和特点包括：

事件监听器管理：它维护了一个事件监听器的集合，并提供添加和移除监听器的方法，如 addApplicationListener 和 removeApplicationListener。

广播事件：它提供了 multicastEvent 方法，该方法负责广播事件给所有注册的监听器。这个方法在 SimpleApplicationEventMulticaster 中通常被直接调用。

任务执行器：和 SimpleApplicationEventMulticaster 一样，AbstractApplicationEventMulticaster 也可以配置一个 TaskExecutor 来支持异步事件广播。如果配置了 TaskExecutor，事件广播将在单独的线程中执行。

错误处理：AbstractApplicationEventMulticaster 提供了一种机制来处理事件广播过程中发生的异常。默认情况下，它会记录异常信息，但不会中断事件的广播。

扩展性：AbstractApplicationEventMulticaster 的设计为子类化提供了空间。例如，子类可以重写 retrieveApplicationListeners 方法来定制监听器的检索逻辑，或者重写 multicastEvent 方法来定制事件广播的行为。

事件类型匹配：AbstractApplicationEventMulticaster 负责确保事件只被那些能够处理它们的监听器接收。这通常是通过检查监听器注册时指定的事件类型来实现的。

在实际使用中，AbstractApplicationEventMulticaster 通常不会直接实例化。相反，你会使用它的具体实现，如 SimpleApplicationEventMulticaster，或者在更复杂的场景下，可能会创建一个自定义的子类来满足特定的需求。

源码

public abstract class AbstractApplicationEventMulticaster
		implements ApplicationEventMulticaster, BeanClassLoaderAware, BeanFactoryAware {
    //默认的存放多个ApplicationListener对象容器。保存者所有监听器
    private final DefaultListenerRetriever defaultRetriever = new DefaultListenerRetriever();
//缓存Map Key=事件类型和源类型 ,value= 存放多个ApplicationListener对象容器
	final Map<ListenerCacheKey, CachedListenerRetriever> retrieverCache = new ConcurrentHashMap<>(64);

	@Nullable
	private ClassLoader beanClassLoader;//类加载器

	@Nullable
	private ConfigurableBeanFactory beanFactory;//bean工厂
    
    public void addApplicationListener(ApplicationListener<?> listener) {
        // 加锁，保证线程安全
		synchronized (this.defaultRetriever) {
			//显示删除代理的目标(如果已经注册)，以避免对同一个监听器的两次调用
			Object singletonTarget = AopProxyUtils.getSingletonTarget(listener);
			if (singletonTarget instanceof ApplicationListener) {
				this.defaultRetriever.applicationListeners.remove(singletonTarget);
			}
            //将listener添加到 defaultRetriever.applicationListeners 中
			this.defaultRetriever.applicationListeners.add(listener);
            //清空缓存，因为 listener 可能支持缓存的某些事件类型和源类型 ，所以要刷新缓存
			this.retrieverCache.clear();
		}
	}
    @Override
	public void addApplicationListenerBean(String listenerBeanName) {
		//使用 retrievalMutex 加锁，保证线程安全
		synchronized (this.retrievalMutex) {
			//将 listenerBeanName 添加到 defaultRetriever的applicationListenerBeans
			this.defaultRetriever.applicationListenerBeans.add(listenerBeanName);
			//清空缓存，因为 listener 可能支持缓存的某些事件类型和源类型 ，所以要刷新缓存
			this.retrieverCache.clear();
		}
	}

	@Override
	public void removeApplicationListener(ApplicationListener<?> listener) {
		//使用 retrievalMutex 加锁，保证线程安全
		synchronized (this.retrievalMutex) {
			//将 listener 从 retriever的ApplicationListener 对象集合中 移除
			this.defaultRetriever.applicationListeners.remove(listener);
			//清空缓存，因为 listener 可能支持缓存的某些事件类型和源类型 ，所以要刷新缓存
			this.retrieverCache.clear();
		}
	}

	@Override
	public void removeApplicationListenerBean(String listenerBeanName) {
		//使用 retrievalMutex 加锁，保证线程安全
		synchronized (this.retrievalMutex) {
			//将 listener 从 retriever的ApplicationListener 对象集合中 移除
			this.defaultRetriever.applicationListenerBeans.remove(listenerBeanName);
			//清空缓存，因为 listener 可能支持缓存的某些事件类型和源类型 ，所以要刷新缓存
			this.retrieverCache.clear();
		}
	}

	@Override
	public void removeAllListeners() {
		//使用 retrievalMutex 加锁，保证线程安全
		synchronized (this.retrievalMutex) {
			//清空 defaultRetriever 的ApplicationListener 对象集合
			this.defaultRetriever.applicationListeners.clear();
			//清空 defaultRetriever 的 BeanFactory中的 applicationListener 类型 Bean名 集合
			this.defaultRetriever.applicationListenerBeans.clear();
			//清空缓存，因为 listener 可能支持缓存的某些事件类型和源类型 ，所以要刷新缓存
			this.retrieverCache.clear();
		}
	}
    
    protected Collection<ApplicationListener<?>> getApplicationListeners() {
		//使用 retrievalMutex 加锁，保证线程安全
		synchronized (this.retrievalMutex) {
			//返回 defaultRetriever 的包含所有 applicationListenere 的集合
			return this.defaultRetriever.getApplicationListeners();
		}
	}
protected Collection<ApplicationListener<?>> getApplicationListeners(
			ApplicationEvent event, ResolvableType eventType) {
		//event.getSource:事件最初在其上发生的对象。
		//获取event最初在其上发生的对象
		Object source = event.getSource();
		//如果source不为nul就获取source的Class对象；否则引用null
		Class<?> sourceType = (source != null ? source.getClass() : null);
		//根据 eventType和 sourceType 新建一个 ListenerRetievers 缓存键
		ListenerCacheKey cacheKey = new ListenerCacheKey(eventType, sourceType);

		// Quick check for existing entry on ConcurrentHashMap...
		// 在 ConcurrentHashMap 上快速检查现有条目
		// 从retrieverCache中获取 cacheKey 对应的 ListenerRetriever对象
		ListenerRetriever retriever = this.retrieverCache.get(cacheKey);
		//如果 retriever 不为 null
		if (retriever != null) {
			//获取 ListenerRetriever 存放的所有 ApplicationListener 对象
			return retriever.getApplicationListeners();
		}

		//ClassUtils.isCacheSafe(Class<?> clazz,@Nullable ClassLoader classLoader):检查给定的类对象在给定的上下文中是否缓
		// 	存安全，即判断是否由 给定的类加载器或者给定的类加载的父级类加载器加载过
		//如果 beanClassLoader 为null || (event的Class对象已经被 beanClassLoader 加载过 && (sourceType 为 null ||
		// 	sourceType已经被 beanClassLoader 加载过))
		if (this.beanClassLoader == null ||
				(ClassUtils.isCacheSafe(event.getClass(), this.beanClassLoader) &&
						(sourceType == null || ClassUtils.isCacheSafe(sourceType, this.beanClassLoader)))) {
			// Fully synchronized building and caching of a ListenerRetriever
			// ListenerRetriever 完全同步的构建和缓存
			// 使用 retrievalMutex 加锁保证线程安全
			synchronized (this.retrievalMutex) {
				//从retrieverCache中获取 cacheKey 对应的 ListenerRetriever对象
				retriever = this.retrieverCache.get(cacheKey);
				//如果 retriever 不为 null
				if (retriever != null) {
					//获取 ListenerRetriever 存放的所有 ApplicationListener 对象
					return retriever.getApplicationListeners();
				}
				//新建一个 ListenerRetriever 对象
				retriever = new ListenerRetriever(true);
				//过滤出所有支持eventType以及sourceType的ApplicationListener对象的列表
				Collection<ApplicationListener<?>> listeners =
						retrieveApplicationListeners(eventType, sourceType, retriever);
				//将 cacheKey,retriever 绑定到 retrieverCache中
				this.retrieverCache.put(cacheKey, retriever);
				//返回 listeners
				return listeners;
			}
		}
		else {
			// No ListenerRetriever caching -> no synchronization necessary
			// 没有 ListenerRetriever 缓存 -> 不需要同步
			//过滤出所有支持eventType以及sourceType的ApplicationListener对象的列表，不使用缓存
			return retrieveApplicationListeners(eventType, sourceType, null);
		}
	}

	private Collection<ApplicationListener<?>> retrieveApplicationListeners(
			ResolvableType eventType, @Nullable Class<?> sourceType, @Nullable ListenerRetriever retriever) {
		//存放所有支持eventType以及sourceType的ApplicationListener 对象 的列表
		List<ApplicationListener<?>> allListeners = new ArrayList<>();
		Set<ApplicationListener<?>> listeners;
		Set<String> listenerBeans;
		//使用 retrievalMutex 加锁，保证线程安全
		synchronized (this.retrievalMutex) {
			//初始化  编程方式添加的静态 ApplicationListener 对象集合
			listeners = new LinkedHashSet<>(this.defaultRetriever.applicationListeners);
			// 初始化 BeanFactory中的 applicationListener 类型 Bean名 集合
			listenerBeans = new LinkedHashSet<>(this.defaultRetriever.applicationListenerBeans);
		}

		// Add programmatically registered listeners, including ones coming
		// from ApplicationListenerDetector (singleton beans and inner beans).
		// 添加以编程方式注册的监听器，包括来自 ApplicationListenerDeteor(单例Bean和内部Bean)的监听器
		// 遍历listeners
		for (ApplicationListener<?> listener : listeners) {
			//如果 listener 支持 eventType 事件类型以及 sourceType 源类型
			if (supportsEvent(listener, eventType, sourceType)) {
				//如果 retriever 不为null
				if (retriever != null) {
					//将 listener添加到 retriever的ApplicationListener 对象集合中
					retriever.applicationListeners.add(listener);
				}
				//将 listener添加到 allListeners 中
				allListeners.add(listener);
			}
		}

		// Add listeners by bean name, potentially overlapping with programmatically
		// registered listeners above - but here potentially with additional metadata.
		// 按Bean名称添加监听器，可能与编程方式重叠————但这里可能有额外的元数据
		// 如果listenerBean不是空集
		if (!listenerBeans.isEmpty()) {
			//获取当前BeanFactory
			ConfigurableBeanFactory beanFactory = getBeanFactory();
			//遍历 listenerBeans
			for (String listenerBeanName : listenerBeans) {
				try {
					//如果通过在尝试实例化listenerBeanName的BeanDefinition的监听器之前检查到 其泛型声明的事件类型支持 eventType
					if (supportsEvent(beanFactory, listenerBeanName, eventType)) {
						//从beanFactory中获取名为 listenerBeanName 的 ApplicationListener 类型的Bean对象
						ApplicationListener<?> listener =
								beanFactory.getBean(listenerBeanName, ApplicationListener.class);
						//如果 allListeners不包含 listener &&  listener 支持 eventType 事件类型以及 sourceType 源类型
						if (!allListeners.contains(listener) && supportsEvent(listener, eventType, sourceType)) {
							//如果 retriever 不为null
							if (retriever != null) {
								//如果 listenerBeanName 在 beanFactory中的Bean对象是单例
								if (beanFactory.isSingleton(listenerBeanName)) {
									//将 listener添加到 retriever的ApplicationListener 对象集合中
									retriever.applicationListeners.add(listener);
								}
								else {
									//将 listener添加到 allListeners 中
									retriever.applicationListenerBeans.add(listenerBeanName);
								}
							}
							//将 listener添加到 allListeners 中
							allListeners.add(listener);
						}
					}
					else {
						// Remove non-matching listeners that originally came from
						// ApplicationListenerDetector, possibly ruled out by additional
						// BeanDefinition metadata (e.g. factory method generics) above.
						// 删除最初来自 ApplicationListenerDetector 的不匹配监听器，可能被上面附加的 BeanDefinition元数据
						// (例如工厂方法泛型) 排除
						// 获取 在 beanFactory 中  listenerBeanName 的 Bean对象
						Object listener = beanFactory.getSingleton(listenerBeanName);
						//retriever不为null
						if (retriever != null) {
							//将 listener 从 retriever的ApplicationListener 对象集合中 移除
							retriever.applicationListeners.remove(listener);
						}
						//将 listener 从 allListeners 移除
						allListeners.remove(listener);
					}
				}
				catch (NoSuchBeanDefinitionException ex) {// 没有这样的BeanDefinition异常
					// Singleton listener instance (without backing bean definition) disappeared -
					// probably in the middle of the destruction phase
					// 单例监听器实例(没有支持BeanDefinition)消失了————可能在销毁阶段的中间
				}
			}
		}
		//AnnotationAwareOrderComparator：OrderComparator的扩展,它支持Spring 的org.springframework.core.Ordered接口以及@Oreder和@Priority注解,
		// 	其中 Ordered实例提供的Order值将覆盖静态定义的注解值(如果有)
		//使用 AnnotationAwareOrderComparator 对 allListeners 进行排序
		AnnotationAwareOrderComparator.sort(allListeners);
		//如果 retriever 不为null && retriever的applicationListenerBeans是空集
		if (retriever != null && retriever.applicationListenerBeans.isEmpty()) {
			//将 retriever的 applicationListeners 的元素情空
			retriever.applicationListeners.clear();
			//将allListeners添加到  retriever的 applicationListeners
			retriever.applicationListeners.addAll(allListeners);
		}
		//返回 allListeners
		return allListeners;
	}
    
	private boolean supportsEvent(
			ConfigurableBeanFactory beanFactory, String listenerBeanName, ResolvableType eventType) {
		//获取 listenerBeanName 在 beanFactory 中的 Class对象
		Class<?> listenerType = beanFactory.getType(listenerBeanName);
		//GenericApplicationListener：标准 ApplicationListener 接口的扩展变体，公开更多的元数据，比如受支持的事件 和 源类型。
		//			在Spring Framework 4.2中，这个接口用通用事件类型的完全处理取代了基于类的SmartApplicationListener
		//SmartApplicationListener：标准ApplicationListener接口扩展变体，公开更多的元数据，比如受支持的事件和源类型。
		//			对于泛型事件类型的完全内省，可以考虑实现 GenericApplictionListener 接口
		//如果 listenerType为null || listenerType 是 GenericApplicationListener 的子类或本身 || listenerType
		// 是 SmartApplicationListener 子类或本身
		if (listenerType == null || GenericApplicationListener.class.isAssignableFrom(listenerType) ||
				SmartApplicationListener.class.isAssignableFrom(listenerType)) {
			//返回true
			return true;
		}
		//如果 listenerType 不支持 eventType 的事件对象
		if (!supportsEvent(listenerType, eventType)) {
			//返回false
			return false;
		}
		try {
			//从 beanFactory 中获取listenerBeanName的合并BeanDefinition，如有必要，将子bean定义与 其父级合并
			BeanDefinition bd = beanFactory.getMergedBeanDefinition(listenerBeanName);
			//获取bd指定的Bean类的ResolvableType对象，然后转换为ApplicationListener的ResolvableType，最后获取第一个泛型参数的ResolveableType
			ResolvableType genericEventType = bd.getResolvableType().as(ApplicationListener.class).getGeneric();
			//如果 genericEventType 是 ResolvableType.NONE || eventType 是 genericEventType 的子类或实现，就返回true；否则返回false
			return (genericEventType == ResolvableType.NONE || genericEventType.isAssignableFrom(eventType));
		}
		catch (NoSuchBeanDefinitionException ex) {//捕捉 没有这样BeanDefinition异常
			// Ignore - no need to check resolvable type for manually registered singleton
			// 忽略 —— 对于手动注册的单例，不需要检查可解析类型
			// 返回true
			return true;
		}
	}

	protected boolean supportsEvent(Class<?> listenerType, ResolvableType eventType) {
		//解析listenerType声明的事件类型
		ResolvableType declaredEventType = GenericApplicationListenerAdapter.resolveDeclaredEventType(listenerType);
		//如果 declaredEventType 为 null || eventType 是 declaredEventType 的子类或本身
		return (declaredEventType == null || declaredEventType.isAssignableFrom(eventType));
	}

	protected boolean supportsEvent(
			ApplicationListener<?> listener, ResolvableType eventType, @Nullable Class<?> sourceType) {
		//如果listener是GenericApplicationListener实例，将将其强转为GenericApplicationListener对象，否则创建一个
		// 	GenericApplicationListenerAdapter 对象来封装listener作为 GenericApplicationListener 对象
		GenericApplicationListener smartListener = (listener instanceof GenericApplicationListener ?
				(GenericApplicationListener) listener : new GenericApplicationListenerAdapter(listener));
		//如果 smartListener 支持 eventType 事件类型 && smartListener 支持 sourceType 源类型【源类型是指产生 eventType 类型的对象的类】
		return (smartListener.supportsEventType(eventType) && smartListener.supportsSourceType(sourceType));
	}
}
//内部类
/**
	 * Cache key for ListenerRetrievers, based on event type and source type.
	 * <p>根据 事件类型 和 源类型 为 ListenerRetievers 缓存键 </p>
	 */
	private static final class ListenerCacheKey implements Comparable<ListenerCacheKey> {

		private final ResolvableType eventType;

		@Nullable
		private final Class<?> sourceType;

		/**
		 * 根据 eventType和 sourceType 新建一个  ListenerRetievers 缓存键
		 * @param eventType 事件类型
		 * @param sourceType 源类型
		 */
		public ListenerCacheKey(ResolvableType eventType, @Nullable Class<?> sourceType) {
			//如果eventType为null，抛出异常
			Assert.notNull(eventType, "Event type must not be null");
			this.eventType = eventType;
			this.sourceType = sourceType;
		}

		@Override
		public boolean equals(@Nullable Object other) {
			//如果 other 与 this 是同一个对象
			if (this == other) {
				//返回true
				return true;
			}
			//如果 other 不是 ListenerCacheKey 的实例
			if (!(other instanceof ListenerCacheKey)) {
				// 返回 false
				return false;
			}
			//将 other 强转为 ListenerCacheKey 对象
			ListenerCacheKey otherKey = (ListenerCacheKey) other;
			//ObjectUtils.nullSafeEquals:确定给定的对象是否相等，如果两个都为null返回true ,如果其中一个为null，返回false
			//如果 eventType 与 otherKey.eventType 相同 &&  sourceType 与 otherKey.sourceType 相同 时，返回true；否则返回false
			return (this.eventType.equals(otherKey.eventType) &&
					ObjectUtils.nullSafeEquals(this.sourceType, otherKey.sourceType));
		}

		@Override
		public int hashCode() {
			return this.eventType.hashCode() * 29 + ObjectUtils.nullSafeHashCode(this.sourceType);
		}

		@Override
		public String toString() {
			return "ListenerCacheKey [eventType = " + this.eventType + ", sourceType = " + this.sourceType + "]";
		}

		@Override
		public int compareTo(ListenerCacheKey other) {
			// 获取比较 eventype 序列化成字符串 与 other.eventType序列化成字符串 的结果
			int result = this.eventType.toString().compareTo(other.eventType.toString());
			// 如果result为0时
			if (result == 0) {
				//如果 sourceType为null
				if (this.sourceType == null) {
					//如果 other.sourceType 为 null，返回 0；否则返回-1
					return (other.sourceType == null ? 0 : -1);
				}
				//如果 other.sourceType为null
				if (other.sourceType == null) {
					//返回 1
					return 1;
				}
				//获取比较 sourceType 类名 与 other.sourceType 类名 的结果
				result = this.sourceType.getName().compareTo(other.sourceType.getName());
			}
			return result;
		}
	}

//缓存
private class CachedListenerRetriever {

		@Nullable
		public volatile Set<ApplicationListener<?>> applicationListeners;

		@Nullable
		public volatile Set<String> applicationListenerBeans;

		@Nullable
		public Collection<ApplicationListener<?>> getApplicationListeners() {
			Set<ApplicationListener<?>> applicationListeners = this.applicationListeners;
			Set<String> applicationListenerBeans = this.applicationListenerBeans;
			if (applicationListeners == null || applicationListenerBeans == null) {
				return null;
			}

			List<ApplicationListener<?>> allListeners = new ArrayList<>(
					applicationListeners.size() + applicationListenerBeans.size());
			allListeners.addAll(applicationListeners);
			if (!applicationListenerBeans.isEmpty()) {
				BeanFactory beanFactory = getBeanFactory();
				for (String listenerBeanName : applicationListenerBeans) {
					try {
						allListeners.add(beanFactory.getBean(listenerBeanName, ApplicationListener.class));
					}
					catch (NoSuchBeanDefinitionException ex) {
						// Singleton listener instance (without backing bean definition) 
					}
				}
			}
			if (!applicationListenerBeans.isEmpty()) {
				AnnotationAwareOrderComparator.sort(allListeners);
			}
			return allListeners;
		}
	}


	private class DefaultListenerRetriever {
		//默认监听器存放集合
		public final Set<ApplicationListener<?>> applicationListeners = new LinkedHashSet<>();
		//存放监听器beanName
		public final Set<String> applicationListenerBeans = new LinkedHashSet<>();

		public Collection<ApplicationListener<?>> getApplicationListeners() {
			List<ApplicationListener<?>> allListeners = new ArrayList<>(
					this.applicationListeners.size() + this.applicationListenerBeans.size());
			allListeners.addAll(this.applicationListeners);
			if (!this.applicationListenerBeans.isEmpty()) {
				BeanFactory beanFactory = getBeanFactory();
				for (String listenerBeanName : this.applicationListenerBeans) {
					try {
                        //从bean工厂中根据beanName获取bean
						ApplicationListener<?> listener =
								beanFactory.getBean(listenerBeanName, ApplicationListener.class);
						if (!allListeners.contains(listener)) {
                            //如果集合中不存在，则放入
							allListeners.add(listener);
						}
					}
					catch (NoSuchBeanDefinitionException ex) {
					}
				}
			}
            //排序
			AnnotationAwareOrderComparator.sort(allListeners);
			return allListeners;
		}
	}

示例

这里是一个使用 AbstractApplicationEventMulticaster（实际上是 SimpleApplicationEventMulticaster）的简单示例：

@Configuration  
public class AppConfig implements ApplicationListener<ApplicationEvent> {  
  
    private final List<ApplicationListener<?>> applicationListeners = new ArrayList<>();  
  
    @Autowired  
    private ApplicationEventMulticaster applicationEventMulticaster;  
  
    @Override  
    public void onApplicationEvent(ApplicationEvent event) {  
        // 处理事件  
    }  
  
    @Bean  
    public ApplicationEventMulticaster customApplicationEventMulticaster() {  
        SimpleApplicationEventMulticaster multicaster = new SimpleApplicationEventMulticaster();  
        multicaster.setApplicationListeners(applicationListeners);  
        multicaster.afterPropertiesSet();  
        return multicaster;  
    }  
  
    @Bean  
    public MyCustomListener myCustomListener() {  
        return new MyCustomListener();  
    }  
  
    // 其他配置...  
}  
  
public class MyCustomListener implements ApplicationListener<CustomEvent> {  
    @Override  
    public void onApplicationEvent(CustomEvent event) {  
        // 处理 CustomEvent  
    }  
}

在这个示例中，AppConfig 类实现了 ApplicationListener 接口，并定义了一个 customApplicationEventMulticaster 方法来创建一个自定义的 ApplicationEventMulticaster bean。这个自定义的广播器被配置为使用 applicationListeners 列表中的监听器。同时，还定义了一个 MyCustomListener 类，它监听 CustomEvent 类型的事件。当 CustomEvent 被发布时，MyCustomListener 的 onApplicationEvent 方法将被调用。