springboot源碼解析(四)：監聽器

監聽器在spring中應用很多，觀察者模式和spring 中的觀察者模式結構對比圖如下

1 觀察者模式結構對比圖如下：

以springboot的源碼爲例，

2 邏輯執行過程

• 1 事件源來發布不同的事件
• 2 當發佈事件之後會調用多播器的方法來進行事件廣播操作，由多播器去出發具體的監聽器去執行操作
• 3 監聽器接收到具體的事件之後，可以驗證匹配是否能處理當前事件，如果可以，直接處理，反之，不作任何操作。

3 實際代碼處理過程

• 1 提前準備好N多個事件
• 2 初始化多播器（創建多播器對象，此多播器對象中應該包含一個監聽器的集合）
• 3 準備好一系列的監聽器
• 4 向多播器中註冊進去已有的監聽器
• 5 準備事件發佈，來通知多播器循環調用監聽器進行相關的邏輯處理工作

4 具體code如下：

在springboot的監聽器有如下兩類：

# Run Listeners
#事件發佈運行監聽器，是springboot中配置的唯一一個應用運行監聽器，作用是通過一個多路廣播器，將springboot運行狀態的變化，構建成事件，並廣播給各個監聽器
org.springframework.boot.SpringApplicationRunListener=\
org.springframework.boot.context.event.EventPublishingRunListener

# Application Listeners
org.springframework.context.ApplicationListener=\
org.springframework.boot.ClearCachesApplicationListener(),\
org.springframework.boot.builder.ParentContextCloserApplicationListener,\
org.springframework.boot.cloud.CloudFoundryVcapEnvironmentPostProcessor,\
org.springframework.boot.context.FileEncodingApplicationListener,\
org.springframework.boot.context.config.AnsiOutputApplicationListener,\
org.springframework.boot.context.config.ConfigFileApplicationListener,\
org.springframework.boot.context.config.DelegatingApplicationListener,\
org.springframework.boot.context.logging.ClasspathLoggingApplicationListener,\
org.springframework.boot.context.logging.LoggingApplicationListener,\
org.springframework.boot.liquibase.LiquibaseServiceLocatorApplicationListener

# Application Listeners
org.springframework.context.ApplicationListener=\
org.springframework.boot.autoconfigure.BackgroundPreinitializer

當程序開始運行的時候，可以看到啓動了一個運行時監聽器，並且創建了一個SpringApplicationRunListeners對象，該對象是一個封裝工具類，封裝了所有的啓動監聽器：代碼如下

class SpringApplicationRunListeners {

    private final Log log;

    //啓動類監聽器
    private final List<SpringApplicationRunListener> listeners;

    SpringApplicationRunListeners(Log log, Collection<? extends SpringApplicationRunListener> listeners) {
        this.log = log;
        this.listeners = new ArrayList<>(listeners);
    }

    //啓動上下文事件監聽
    void starting() {
        for (SpringApplicationRunListener listener : this.listeners) {
            listener.starting();
        }
    }

    //environment準備完畢事件監聽
    void environmentPrepared(ConfigurableEnvironment environment) {
        for (SpringApplicationRunListener listener : this.listeners) {
            listener.environmentPrepared(environment);
        }
    }

    //spring上下文準備完畢事件監聽
    void contextPrepared(ConfigurableApplicationContext context) {
        for (SpringApplicationRunListener listener : this.listeners) {
            listener.contextPrepared(context);
        }
    }

    //上下文配置類加載事件監聽
    void contextLoaded(ConfigurableApplicationContext context) {
        for (SpringApplicationRunListener listener : this.listeners) {
            listener.contextLoaded(context);
        }
    }

    //上下文刷新調用事件
    void started(ConfigurableApplicationContext context) {
        for (SpringApplicationRunListener listener : this.listeners) {
            listener.started(context);
        }
    }

    //上下文刷新完成，在run方法執行完之前調用該事件
    void running(ConfigurableApplicationContext context) {
        for (SpringApplicationRunListener listener : this.listeners) {
            listener.running(context);
        }
    }

    //在運行過程中失敗調起的事件
    void failed(ConfigurableApplicationContext context, Throwable exception) {
        for (SpringApplicationRunListener listener : this.listeners) {
            callFailedListener(listener, context, exception);
        }
    }

    private void callFailedListener(SpringApplicationRunListener listener, ConfigurableApplicationContext context,
            Throwable exception) {
        try {
            listener.failed(context, exception);
        }
        catch (Throwable ex) {
            if (exception == null) {
                ReflectionUtils.rethrowRuntimeException(ex);
            }
            if (this.log.isDebugEnabled()) {
                this.log.error("Error handling failed", ex);
            }
            else {
                String message = ex.getMessage();
                message = (message != null) ? message : "no error message";
                this.log.warn("Error handling failed (" + message + ")");
            }
        }
    }
}

在啓動源碼的流程中，我們知道不同的方法會在不同的時間點觸發執行，然後廣播出不同的事件，進入到EventPublishingRunListener類中

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);
		}
	}

在當前類的構造方法中默認創建了SimpleApplicationEventMulticaster類，用來完成創建全局的事件發佈功能

@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 contextPrepared(ConfigurableApplicationContext context) {
		this.initialMulticaster
				.multicastEvent(new ApplicationContextInitializedEvent(this.application, this.args, context));
	}

	@Override
	public void contextLoaded(ConfigurableApplicationContext context) {
		for (ApplicationListener<?> listener : this.application.getListeners()) {
			if (listener instanceof ApplicationContextAware) {
				((ApplicationContextAware) listener).setApplicationContext(context);
			}
			context.addApplicationListener(listener);
		}
		this.initialMulticaster.multicastEvent(new ApplicationPreparedEvent(this.application, this.args, context));
	}

	@Override
	public void started(ConfigurableApplicationContext context) {
		context.publishEvent(new ApplicationStartedEvent(this.application, this.args, context));
	}

	@Override
	public void running(ConfigurableApplicationContext context) {
		context.publishEvent(new ApplicationReadyEvent(this.application, this.args, context));
	}

	@Override
	public void failed(ConfigurableApplicationContext context, Throwable exception) {
		ApplicationFailedEvent event = new ApplicationFailedEvent(this.application, this.args, context, exception);
		if (context != null && context.isActive()) {
			// Listeners have been registered to the application context so we should
			// use it at this point if we can
			context.publishEvent(event);
		}
		else {
			// An inactive context may not have a multicaster so we use our multicaster to
			// call all of the context's listeners instead
			if (context instanceof AbstractApplicationContext) {
				for (ApplicationListener<?> listener : ((AbstractApplicationContext) context)
						.getApplicationListeners()) {
					this.initialMulticaster.addApplicationListener(listener);
				}
			}
			this.initialMulticaster.setErrorHandler(new LoggingErrorHandler());
			this.initialMulticaster.multicastEvent(event);
		}
	}

在進行事件廣播的時候，會進入如下方法：

@Override
	public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
		ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
        //獲取線程池
		Executor executor = getTaskExecutor();
        //根據事件類型選取需要通知的監聽器
		for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {
			//如果不爲空，則異步執行	
            if (executor != null) {
				executor.execute(() -> invokeListener(listener, event));
			}
			else {
                //如果爲空，則同步執行
				invokeListener(listener, event);
			}
		}
	}

在進行事件廣播之前，需要將監聽器進行過濾，符合類型的留下，不符合類型的過濾掉

protected Collection<ApplicationListener<?>> getApplicationListeners(
   		ApplicationEvent event, ResolvableType eventType) {

   	Object source = event.getSource();
   	Class<?> sourceType = (source != null ? source.getClass() : null);
   	ListenerCacheKey cacheKey = new ListenerCacheKey(eventType, sourceType);

   	// Quick check for existing entry on ConcurrentHashMap...
   	ListenerRetriever retriever = this.retrieverCache.get(cacheKey);
   	if (retriever != null) {
   		return retriever.getApplicationListeners();
   	}

   	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
   		synchronized (this.retrievalMutex) {
   			retriever = this.retrieverCache.get(cacheKey);
   			if (retriever != null) {
   				return retriever.getApplicationListeners();
   			}
   			retriever = new ListenerRetriever(true);
   			Collection<ApplicationListener<?>> listeners =
   					retrieveApplicationListeners(eventType, sourceType, retriever);
   			this.retrieverCache.put(cacheKey, retriever);
   			return listeners;
   		}
   	}
   	else {
   		// No ListenerRetriever caching -> no synchronization necessary
   		return retrieveApplicationListeners(eventType, sourceType, null);
   	}
   }

​ 實際處理判斷邏輯的類：

private Collection<ApplicationListener<?>> retrieveApplicationListeners(
			ResolvableType eventType, @Nullable Class<?> sourceType, @Nullable ListenerRetriever retriever) {

		List<ApplicationListener<?>> allListeners = new ArrayList<>();
		Set<ApplicationListener<?>> listeners;
		Set<String> listenerBeans;
		synchronized (this.retrievalMutex) {
			listeners = new LinkedHashSet<>(this.defaultRetriever.applicationListeners);
			listenerBeans = new LinkedHashSet<>(this.defaultRetriever.applicationListenerBeans);
		}

		// Add programmatically registered listeners, including ones coming
		// from ApplicationListenerDetector (singleton beans and inner beans).
		for (ApplicationListener<?> listener : listeners) {
			if (supportsEvent(listener, eventType, sourceType)) {
				if (retriever != null) {
					retriever.applicationListeners.add(listener);
				}
				allListeners.add(listener);
			}
		}

		// Add listeners by bean name, potentially overlapping with programmatically
		// registered listeners above - but here potentially with additional metadata.
		if (!listenerBeans.isEmpty()) {
			ConfigurableBeanFactory beanFactory = getBeanFactory();
			for (String listenerBeanName : listenerBeans) {
				try {
					if (supportsEvent(beanFactory, listenerBeanName, eventType)) {
						ApplicationListener<?> listener =
								beanFactory.getBean(listenerBeanName, ApplicationListener.class);
						if (!allListeners.contains(listener) && supportsEvent(listener, eventType, sourceType)) {
							if (retriever != null) {
								if (beanFactory.isSingleton(listenerBeanName)) {
									retriever.applicationListeners.add(listener);
								}
								else {
									retriever.applicationListenerBeans.add(listenerBeanName);
								}
							}
							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.
						Object listener = beanFactory.getSingleton(listenerBeanName);
						if (retriever != null) {
							retriever.applicationListeners.remove(listener);
						}
						allListeners.remove(listener);
					}
				}
				catch (NoSuchBeanDefinitionException ex) {
					// Singleton listener instance (without backing bean definition) disappeared -
					// probably in the middle of the destruction phase
				}
			}
		}

		AnnotationAwareOrderComparator.sort(allListeners);
		if (retriever != null && retriever.applicationListenerBeans.isEmpty()) {
			retriever.applicationListeners.clear();
			retriever.applicationListeners.addAll(allListeners);
		}
		return allListeners;
	}

在監聽器實例化之前，檢查是否符合固定的類型

		protected boolean supportsEvent(
			ApplicationListener<?> listener, ResolvableType eventType, @Nullable Class<?> sourceType) {
		//判斷監聽器是否是GenericApplicationListener子類，如不是返回一個GenericApplicationListenerAdapter
		GenericApplicationListener smartListener = (listener instanceof GenericApplicationListener ?
				(GenericApplicationListener) listener : new GenericApplicationListenerAdapter(listener));
		return (smartListener.supportsEventType(eventType) && smartListener.supportsSourceType(sourceType));
	}

public interface GenericApplicationListener extends ApplicationListener<ApplicationEvent>, Ordered {
	boolean supportsEventType(ResolvableType eventType);
	default boolean supportsSourceType(@Nullable Class<?> sourceType) {
		return true;
	}
	@Override
	default int getOrder() {
		return LOWEST_PRECEDENCE;
	}

}

此時可以看到GenericApplicationListener類，該類是spring提供的用於重寫匹配監聽器事件的接口，如果需要判斷的監聽器是GenericApplicationListener的子類，說明類型匹配方法已被重現，就調用子類的匹配方法，如果不是，提供一個默認的適配器來匹配GenericApplicationListenerAdapter

	public boolean supportsEventType(ResolvableType eventType) {
		if (this.delegate instanceof SmartApplicationListener) {
			Class<? extends ApplicationEvent> eventClass = (Class<? extends ApplicationEvent>) eventType.resolve();
			return (eventClass != null && ((SmartApplicationListener) this.delegate).supportsEventType(eventClass));
		}
		else {
			return (this.declaredEventType == null || this.declaredEventType.isAssignableFrom(eventType));
		}
	}

可以看到該類最終調用的是declaredEventType.isAssignableFrom(eventType)方法，也就是說，如果我們沒有重寫監聽器匹配方法，那麼發佈的事件 event 會被監聽 event以及監聽event的父類的監聽器監聽到。