spring源码-messageSource和监听器的初始化

痛定思痛。 2024-04-17 20:11 60阅读 0赞

这一节我们来看一下容器启动时messageSource的初始化和监听器的初始化。  
这一节主要的源码分四块：

initMessageSource();
    initApplicationEventMulticaster();
    onRefresh();
    registerListeners();

其中onRefresh方法是留给用户自定义的，所以这里主要看一下其他三个方法的源码。

### initMessageSource ###

protected void initMessageSource() {
    	ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    	//判断beanFactory中是否有messageSource的beanDefinition
    	if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
    		this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
    		//如果有，且满足条件，则设置parent
    		if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
    			HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
    			if (hms.getParentMessageSource() == null) {
    				hms.setParentMessageSource(getInternalParentMessageSource());
    			}
    		}
    		……日志
    	}
    	else {
    		// 如果没有则初始化，并设置parent，最后注册到beanFactory中，这里的parent就是容器的parent，一般为null
    		DelegatingMessageSource dms = new DelegatingMessageSource();
    		dms.setParentMessageSource(getInternalParentMessageSource());
    		this.messageSource = dms;
    		beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
    		……日志
    	}
    }

### initApplicationEventMulticaster ###

protected void initApplicationEventMulticaster() {
        //判断beanFactory中是否存在applicationEventMulticaster的beanDefinition
    	ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    	if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
    		this.applicationEventMulticaster =
    				beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
    		……日志
    	}
    	else {
    	    //如果没有则初始化，并注册
    		this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
    		beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
    		……日志
    	}
    }

### registerListeners ###

在分析registerListeners源码之前，我们先来回顾一下prepareRefresh中的一段源码：

if (this.earlyApplicationListeners == null) {
    	this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
    }
    else {
    	this.applicationListeners.clear();
    	this.applicationListeners.addAll(this.earlyApplicationListeners);
    }
    
    this.earlyApplicationEvents = new LinkedHashSet<>();

通过上面的代码可以看出，spring容器会初始化两个set，earlyApplicationListeners和earlyApplicationEvents  
下面我们来看一下registerListeners的源码：

protected void registerListeners() {
    	//如果在spring容器初始化前earlyApplicationListeners中已经有Listener了，那么这里会执行
    	for (ApplicationListener<?> listener : getApplicationListeners()) {
    		getApplicationEventMulticaster().addApplicationListener(listener);
    	}
    
    	//检测beanDefinition中是否有ApplicationListener的子类如果有，则执行
    	String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
    	for (String listenerBeanName : listenerBeanNames) {
    	    //applicationEventMulticaster为上一步监听器初始化的时候
    		getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
    	}
    
    	//如果earlyApplicationEvents中存在已经发布的事件，则直接执行
    	Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
    	//在容器初始化后，earlyApplicationEvents又会变成null
    	this.earlyApplicationEvents = null;
    	if (earlyEventsToProcess != null) {
    		for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
    			getApplicationEventMulticaster().multicastEvent(earlyEvent);
    		}
    	}
    }

上面这段代码前两步很简单，就是将定义的监听器注册到事件的广播中，但是这里有两个疑问：

1.  earlyApplicationEvents在什么情况下会有数据
2.  在消息发布后，监听器是如何运作的  
    要理解这两个问题，我们需要看一下publishEvent方法的源码：

protected void publishEvent(Object event, @Nullable ResolvableType eventType) {
    	Assert.notNull(event, "Event must not be null");
    
    	//这里会先判断一下event的类型，并最终会转换成ApplicationEvent
    	ApplicationEvent applicationEvent;
    	if (event instanceof ApplicationEvent) {
    		applicationEvent = (ApplicationEvent) event;
    	}
    	else {
    		applicationEvent = new PayloadApplicationEvent<>(this, event);
    		if (eventType == null) {
    			eventType = ((PayloadApplicationEvent<?>) applicationEvent).getResolvableType();
    		}
    	}
    
    	/**
    	* 查看earlyApplicationEvents是不是为空，如果是，那么直接执行事件的监听逻辑
    	* 这里为空情况有两种：
    	* 1. 在容器启动时prepareRefresh之前
    	* 2. 在registerListeners之后，因为在这一步，会将earlyApplicationEvents置空
    	if (this.earlyApplicationEvents != null) {
    		this.earlyApplicationEvents.add(applicationEvent);
    	}
    	else {
    		getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
    	}
    
    	//让父容器也去消费该事件
    	if (this.parent != null) {
    		if (this.parent instanceof AbstractApplicationContext) {
    			((AbstractApplicationContext) this.parent).publishEvent(event, eventType);
    		}
    		else {
    			this.parent.publishEvent(event);
    		}
    	}
    }

从上面的代码，我们知道了第一个问题的答案，至于第二个问题，我们进入执行监听逻辑的代码  
getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType)：

public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
        //解析出这个事件的ResolvableType
    	ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
    	Executor executor = getTaskExecutor();
    	//再根据这个type获取到所有监听这个类型的event的listener（通过onApplicationEvent方法的参数去判断），并且执行
    	for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {
    		if (executor != null) {
    			executor.execute(() -> invokeListener(listener, event));
    		}
    		else {
    			invokeListener(listener, event);
    		}
    	}
    }