### 歡迎訪問我的GitHub
> 這裡分類和彙總了欣宸的全部原創(含配套原始碼)：[https://github.com/zq2599/blog_demos](https://github.com/zq2599/blog_demos)

- 提到廣播與監聽，我們常常會想到RabbitMQ、Kafka等訊息中介軟體，這些常用於分散式系統中多個應用之間，有時候應用自身內部也有廣播和監聽的需求（例如某個核心資料發生變化後，有些業務模組希望立即被感知），這時候spring提供的基於ApplicationContext的廣播與監聽就派上用場了，接下來我們從原理到實踐，來了解spring提供的這套機制吧。

### 全文概覽
- 總的來說本章內容由以下部分構成：
1. 學習廣播服務的核心介面；
2. spring的容器內廣播和監聽的原始碼檢視；
3. spring是如何支援自定義廣播的；
4. spring是如何支援自定義監聽的；
5. 開發一個自定義廣播；
6. 開發一個自定義監聽；

### ApplicationEventPublisher:廣播服務的核心能力
- 提到spring容器中的廣播和監聽，就不得不先看看ApplicationEventPublisher這個介面，今天的故事都是圍繞此君展開：

```java
@FunctionalInterface
public interface ApplicationEventPublisher {

/**
	 * Notify all matching listeners registered with this
	 * application of an application event. Events may be framework events
	 * (such as RequestHandledEvent) or application-specific events.
	 * @param event the event to publish
	 * @see org.springframework.web.context.support.RequestHandledEvent
	 */
	default void publishEvent(ApplicationEvent event) {
		publishEvent((Object) event);
	}

/**
	 * Notify all matching listeners registered with this
	 * application of an event.
	 * If the specified {@code event} is not an {@link ApplicationEvent},
	 * it is wrapped in a {@link PayloadApplicationEvent}.
	 * @param event the event to publish
	 * @since 4.2
	 * @see PayloadApplicationEvent
	 */
	void publishEvent(Object event);

}
```
- 從上述程式碼可以看出，傳送訊息實際上就是在呼叫ApplicationEventPublisher 介面實現類的publishEvent方法，接下來看看類圖，瞭解在spring容器的設計中ApplicationEventPublisher的定位：

![image.png](https://bbs-img.huaweicloud.com/blogs/img/20220613/1655096043572268930.png)

- 從上圖可見，ApplicationContext繼承了ApplicationEventPublisher，那麼ApplicationContext的實現類自然也就具備了傳送廣播的能力，按照這個思路去看一下關鍵的抽象類AbstractApplicationContext，果然找到了方法實現：
```java
@Override
public void publishEvent(ApplicationEvent event) {
	publishEvent(event, null);
}
```

### 如何廣播一條訊息
- 來看一個具體的廣播的例子吧，spring容器初始化結束的時候，會執行AbstractApplicationContext類的finishRefresh方法，裡面就會廣播一條代表初始化結束的訊息，程式碼如下：
```java
protected void finishRefresh() {
	// Clear context-level resource caches (such as ASM metadata from scanning).
	clearResourceCaches();

// Initialize lifecycle processor for this context.
	initLifecycleProcessor();

// Propagate refresh to lifecycle processor first.
	getLifecycleProcessor().onRefresh();

// 廣播一條訊息，型別ContextRefreshedEvent代表spring容器初始化結束
	publishEvent(new ContextRefreshedEvent(this));

// Participate in LiveBeansView MBean, if active.
	LiveBeansView.registerApplicationContext(this);
}
```
- 繼續深入publichEvent方法內部，看到的程式碼如下圖所示：
![image.png](https://bbs-img.huaweicloud.com/blogs/img/20220613/1655096062276725774.png)

- 上圖中的綠色部分的判斷不成立，初始化過程中的registerListeners方法就會把成員變數earlyApplicationEvents設定為空，因此廣播訊息執行的是**getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType)**，在ApplicationContext的實現類中，真正的廣播操作交給了成員變數applicationEventMulticaster來完成，沒有特殊配置的話，applicationEventMulticaster是SimpleApplicationEventMulticaster型別的例項（詳情請看initApplicationEventMulticaster方法）；

- 開啟的原始碼，如下所示，是否有種豁然開朗的感覺？廣播的實現是如此簡單明瞭，找到已註冊的ApplicationListener，逐個呼叫invokeListener方法，將ApplicationListener和事件作為入參傳進去就完成了廣播；
```java
@Override
	public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
		ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
		for (final ApplicationListener> listener : getApplicationListeners(event, type)) {
			Executor executor = getTaskExecutor();
			if (executor != null) {
				executor.execute(() -> invokeListener(listener, event));
			}
			else {
				invokeListener(listener, event);
			}
		}
	}
```

- 看到這裡，invokeListener方法所做的事情已經很容易猜到了，ApplicationListener是代表監聽的介面，只要呼叫這個介面的方法並且將event作為入參傳進去，那麼每個監聽器就可以按需要自己來處理這條廣播訊息了，看了程式碼發現我們的猜測是正確的：
```java
private void doInvokeListener(ApplicationListener listener, ApplicationEvent event) {
		try {
			//這裡就是監聽器收到廣播時做的事情
			listener.onApplicationEvent(event);
		}
		catch (ClassCastException ex) {
			String msg = ex.getMessage();
			if (msg == null || matchesClassCastMessage(msg, event.getClass().getName())) {
				// 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.isDebugEnabled()) {
					logger.debug("Non-matching event type for listener: " + listener, ex);
				}
			}
			else {
				throw ex;
			}
		}
	}
```

- 另外還有個細節需要補充，這是在後面做自定義廣播的時候考慮到的：**如果多執行緒同時發廣播，會不會有執行緒同步的問題？**傳送廣播的原始碼一路看下來，發現操作全部在傳送的執行緒中執行的，對各種成員變數的操作也沒有出現執行緒同步問題，唯一有可能出現問題的地方在獲取ApplicationListener的時候，這裡用到了快取，有快取更新的邏輯，而spring已經做好了鎖來確保執行緒同步（雙重判斷也做了），來看看原始碼，注意中文註釋：
```java
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);

//retrieverCache是個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)))) {
			// 這裡有鎖
			synchronized (this.retrievalMutex) {
				retriever = this.retrieverCache.get(cacheKey);
				//搶到鎖之後再做一次判斷，因為有可能在前面BLOCK的時候，另一個搶到鎖的執行緒已經設定好了快取
				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);
		}
	}
```

- 看到這裡，我們對spring容器內的廣播與監聽已經有所瞭解，小結如下：
1. 廣播的核心介面是ApplicationEventPublisher；
2. 我們見過了如何發起一條廣播，監聽器如何響應廣播；

- 接下來還不能馬上動手實戰，我們還有兩件事情要想弄清楚：
1. 我想發自定義的廣播訊息，如何具備這個傳送能力？
2. 我想接收特定的廣播，如何具備這個接收能力？

- 接下來，繼續結合spring原始碼去找上面兩個問題的答案；

### 原始碼分析(如何具備訊息傳送能力)
- 先看訊息生產相關的原始碼，在上一章[《spring4.1.8擴充套件實戰之二：Aware介面揭秘》](http://blog.itpub.net/70017844/viewspace-2900130/)中，我們看到spring容器初始化的時候會對實現了Aware介面的bean做相關的特殊處理，其中就包含**ApplicationEventPublisherAware**這個與廣播傳送相關的介面，程式碼如下(ApplicationContextAwareProcessor.java)：
```java
private void invokeAwareInterfaces(Object bean) {
		if (bean instanceof Aware) {
			if (bean instanceof EnvironmentAware) {
				((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
			}
			if (bean instanceof EmbeddedValueResolverAware) {
				((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
			}
			if (bean instanceof ResourceLoaderAware) {
				((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
			}

//如果想在應用內傳送廣播，需要開發一個實現了ApplicationEventPublisherAware介面的bean，就會在此被注入一個ApplicationEventPublisher物件，藉助這個物件就能傳送廣播了
			if (bean instanceof ApplicationEventPublisherAware) {
				((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
			}
			if (bean instanceof MessageSourceAware) {
				((MessageSourceAware) bean).setMessageSource(this.applicationContext);
			}
			if (bean instanceof ApplicationContextAware) {
				((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
			}
		}
	}
```
- 由以上程式碼可見，我們可以建立一個bean，實現了ApplicationEventPublisherAware介面，那麼該bean的setApplicationEventPublisher方法就會被呼叫，透過該方法可以接收到ApplicationEventPublisher型別的入參，藉助這個ApplicationEventPublisher就可以發訊息了；

### 原始碼分析(如何具備訊息接收能力)
- 在spring容器初始化的時候，AbstractApplicationContext類的prepareBeanFactory方法中為所有bean準備了一個後置處理器ApplicationListenerDetector，來看看它的postProcessAfterInitialization方法的程式碼，也就是bean在例項化之後要做的事情：
```java
@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) {
		if (bean instanceof ApplicationListener) {
			// potentially not detected as a listener by getBeanNamesForType retrieval
			Boolean flag = this.singletonNames.get(beanName);
			if (Boolean.TRUE.equals(flag)) {
				//註冊監聽器，其實就是儲存在成員變數applicationEventMulticaster的成員變數defaultRetriever的集合applicationListeners中
				this.applicationContext.addApplicationListener((ApplicationListener>) bean);
			}
			else if (Boolean.FALSE.equals(flag)) {
				if (logger.isWarnEnabled() && !this.applicationContext.containsBean(beanName)) {
					// inner bean with other scope - can't reliably process events
					logger.warn("Inner bean '" + beanName + "' implements ApplicationListener interface " +
							"but is not reachable for event multicasting by its containing ApplicationContext " +
							"because it does not have singleton scope. Only top-level listener beans are allowed " +
							"to be of non-singleton scope.");
				}
				this.singletonNames.remove(beanName);
			}
		}
		return bean;
	}
```
- 如上所示，如果當前bean實現了ApplicationListener介面，就會呼叫this.applicationContext.addApplicationListener方法將當前bean註冊到applicationContext的監聽器集合中，後面有廣播就直接找到這些監聽器，呼叫每個監聽器的onApplicationEvent方法；

- 現在把廣播與監聽的關鍵程式碼都看過了，可以開始實戰了麼？稍等，還有最後一個疑問要弄明白：**自定義的訊息監聽器可以指定訊息型別，所有的廣播訊息中，這個監聽器只會收到自己指定的訊息型別的廣播，spring是如何做到這一點的？**

### 如何做到只接收指定型別的訊息
- 此問題的答案就在spring原始碼中，但是看原始碼之前先自己猜測一下，自定義監聽器只接收指定型別的訊息，以下兩種方案都可以實現：
1. 註冊監聽器的時候，將監聽器和訊息型別繫結；
2. 廣播的時候，按照這條訊息的型別去找指定了該型別的監聽器，但不可能每條廣播都去所有監聽器裡面找一遍，應該是說廣播的時候會觸發一次監聽器和訊息的型別繫結；

- 帶著上述猜測去spring原始碼中尋找答案吧，先看註冊監聽器的程式碼，按照之前的分析，註冊監聽發生在後置處理器ApplicationListenerDetector中，看看this.applicationContext.addApplicationListener這一行程式碼的內部邏輯：
```java
@Override
	public void addApplicationListener(ApplicationListener> listener) {
		Assert.notNull(listener, "ApplicationListener must not be null");
		if (this.applicationEventMulticaster != null) {
			this.applicationEventMulticaster.addApplicationListener(listener);
		}
		else {
			this.applicationListeners.add(listener);
		}
	}
```
- 最終跟蹤到AbstractApplicationEventMulticaster類的addApplicationListener方法：
```java
@Override
public void addApplicationListener(ApplicationListener> listener) {
	synchronized (this.retrievalMutex) {
		// Explicitly remove target for a proxy, if registered already,
		// in order to avoid double invocations of the same listener.
		Object singletonTarget = AopProxyUtils.getSingletonTarget(listener);
		if (singletonTarget instanceof ApplicationListener) {
			//如果因為AOP導致建立了監聽類的代理，那麼就要在註冊列表中清除代理類
			this.defaultRetriever.applicationListeners.remove(singletonTarget);
		}
		//把監聽器加入集合defaultRetriever.applicationListeners中，這是個LinkedHashSet例項
		this.defaultRetriever.applicationListeners.add(listener);
		this.retrieverCache.clear();
	}
}
```
- 從以上程式碼我們發現了兩個關鍵點：
- AOP是透過代理技術實現的，此時可能透過CGLIB生成了監聽類的代理類，此類的例項如果也被註冊到監聽器集合中，那麼廣播的時候，按照訊息型別就會取出兩個監聽器例項來了，到時候的效果就是一個訊息被兩個例項消費了，因此這裡要先清理掉代理類；
- 所謂的註冊監聽器，其實就是把ApplicationListener的實現類放入一個LinkedHashSet的集合，此處沒有任何與訊息型別相關的操作，因此，**監聽器註冊的時候並沒有將訊息型別和監聽器繫結**；

- 監聽器註冊的程式碼看過了，沒有繫結，那麼只好去看廣播訊息的程式碼了，好在前面才看過廣播的程式碼，印象還算深刻，再次來到SimpleApplicationEventMulticaster的multicastEvent方法：
```java
@Override
public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
	ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
	//根據訊息型別取出對應的所有監聽器
	for (final ApplicationListener> listener : getApplicationListeners(event, type)) {
		Executor executor = getTaskExecutor();
		if (executor != null) {
			executor.execute(() -> invokeListener(listener, event));
		}
		else {
			invokeListener(listener, event);
		}
	}
}
```
- 如上述程式碼所示，解開我們疑問的關鍵點就在**getApplicationListeners(event, type)**這段程式碼了，也就是說在傳送訊息的時候根據型別去找所有對應的監聽器，展開這個方法一探究竟：
```java
protected Collection<applicationlistener>> getApplicationListeners(
			ApplicationEvent event, ResolvableType eventType) {

Object source = event.getSource();

Class> sourceType = (source != null ? source.getClass() : null);
	//快取的key有兩個維度：訊息來源+訊息型別（關於訊息來源可見ApplicationEvent構造方法的入參）
	ListenerCacheKey cacheKey = new ListenerCacheKey(eventType, sourceType);

// retrieverCache是ConcurrentHashMap物件，所以是執行緒安全的，
	// ListenerRetriever中有個監聽器的集合，並有些簡單的邏輯封裝，呼叫它的getApplicationListeners方法返回的監聽類集合是排好序的(order註解排序)
	ListenerRetriever retriever = this.retrieverCache.get(cacheKey);
	if (retriever != null) {
		//如果retrieverCache中找到對應的監聽器集合，就立即返回了
		return retriever.getApplicationListeners();
	}

if (this.beanClassLoader == null ||
			(ClassUtils.isCacheSafe(event.getClass(), this.beanClassLoader) &&
					(sourceType == null || ClassUtils.isCacheSafe(sourceType, this.beanClassLoader)))) {
		//如果retrieverCache中沒有資料，就在此查出資料並放入快取，
		//先加鎖
		synchronized (this.retrievalMutex) {
			//雙重判斷的第二重，避免自己在BLOCK的時候其他執行緒已經將資料放入快取了
			retriever = this.retrieverCache.get(cacheKey);
			if (retriever != null) {
				return retriever.getApplicationListeners();
			}
			//新建一個ListenerRetriever物件
			retriever = new ListenerRetriever(true);
			//retrieveApplicationListeners方法複製找出某個訊息型別加來源型別對應的所有監聽器
			Collection<applicationlistener>> listeners =
					retrieveApplicationListeners(eventType, sourceType, retriever);
			//存入retrieverCache
			this.retrieverCache.put(cacheKey, retriever);
			//返回結果
			return listeners;
		}
	}
	else {
		// No ListenerRetriever caching -> no synchronization necessary
		return retrieveApplicationListeners(eventType, sourceType, null);
	}
}
```
- 上述程式碼解開了所有疑惑：**在廣播訊息的時刻，如果某個型別的訊息在快取中找不到對應的監聽器集合，就呼叫retrieveApplicationListeners方法去找出符合條件的所有監聽器，然後放入這個集合；**這和之前的猜測匹配度挺高的...

- retrieveApplicationListeners方法在面對各種監聽器的時候處理邏輯過於複雜，就不在這裡展開了；

- 至此，我們對廣播和監聽的原理已經有了較全面的認識，可以動手實戰了；

### 開發一個自定義廣播
- 現在基於maven建立一個SpringBoot的web工程customizeapplicationevent，在工程中自定義一個傳送廣播的bean，在收到一個web請求時，利用該bean發出廣播；
- 建立工程customizeapplicationevent，pom.xml如下：
```xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemalocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelversion>4.0.0</modelversion>
	<groupid>com.bolingcavalry</groupid>
	<artifactid>customizeapplicationevent</artifactid>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>
	<name>customizeapplicationevent</name>
	<description>Demo project for Spring Boot</description>
	<parent>
		<groupid>org.springframework.boot</groupid>
		<artifactid>spring-boot-starter-parent</artifactid>
		<version>2.0.4.RELEASE</version>
		<relativepath></relativepath> 
	</parent>
	<properties>
		<project.build.sourceencoding>UTF-8</project.build.sourceencoding>
		<project.reporting.outputencoding>UTF-8</project.reporting.outputencoding>
		<java.version>1.8</java.version>
	</properties>
	<dependencies>
		<dependency>
			<groupid>org.springframework.boot</groupid>
			<artifactid>spring-boot-starter-web</artifactid>
		</dependency>
		<dependency>
			<groupid>org.springframework.boot</groupid>
			<artifactid>spring-boot-starter-test</artifactid>
			<scope>test</scope>
		</dependency>
	</dependencies>
	<build>
		<plugins>
			<plugin>
				<groupid>org.springframework.boot</groupid>
				<artifactid>spring-boot-maven-plugin</artifactid>
			</plugin>
		</plugins>
	</build>
</project>
```

- 自定義一個訊息型別CustomizeEvent：

```java
package com.bolingcavalry.customizeapplicationevent.event;

import org.springframework.context.ApplicationContext;
import org.springframework.context.event.ApplicationContextEvent;

/**
 * @Description : 自定義的訊息型別
 * @Author : zq2599@gmail.com
 * @Date : 2018-08-16 06:09
 */
public class CustomizeEvent extends ApplicationContextEvent {
    public CustomizeEvent(ApplicationContext source) {
        super(source);
    }
}
```

- 自定義廣播傳送者CustomizePublisher，除了用到ApplicationEventPublisher，還要用到ApplicationContext（構造CustomizeEvent物件的時候要用），所以要實現兩個Aware介面：

```java
package com.bolingcavalry.customizeapplicationevent.publish;

import com.bolingcavalry.customizeapplicationevent.event.CustomizeEvent;
import com.bolingcavalry.customizeapplicationevent.util.Utils;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationEventPublisherAware;
import org.springframework.stereotype.Service;

/**
 * @Description : 自定義的廣播傳送器
 * @Author : zq2599@gmail.com
 * @Date : 2018-08-16 06:09
 */
@Service
public class CustomizePublisher implements ApplicationEventPublisherAware, ApplicationContextAware {

private ApplicationEventPublisher applicationEventPublisher;

private ApplicationContext applicationContext;

@Override
    public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
        this.applicationEventPublisher = applicationEventPublisher;
        Utils.printTrack("applicationEventPublisher is set : " + applicationEventPublisher);
    }

@Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

/**
     * 傳送一條廣播
     */
    public void publishEvent(){
        applicationEventPublisher.publishEvent(new CustomizeEvent(applicationContext));
    }
}
```

- 做一個controller，這樣就能透過web請求來觸發一次廣播了：

```java
package com.bolingcavalry.customizeapplicationevent.controller;

import com.bolingcavalry.customizeapplicationevent.publish.CustomizePublisher;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Date;

/**
 * @Description : 收到web請求後傳送一條廣播
 * @Author : zq2599@gmail.com
 * @Date : 2018-08-16 06:45
 */
@RestController
public class CustomizePublishEventController {

@Autowired
    private CustomizePublisher customizePublisher;

@RequestMapping("/publish")
    public String publish(){

customizePublisher.publishEvent();

return "publish finish, "
                + new Date();
    }
}
```

- 自定義廣播的程式碼已經完成了，不過現在即使把訊息發出去了也不能驗證是否傳送成功，先不要執行工程，接下來把自定義訊息監聽也做了吧；

### 開發兩個自定義監聽器
- 我們要做兩個自定義監聽器；
- 第一個監聽類在泛型中定義的型別是ApplicationEvent，即接收所有廣播訊息；

```java
package com.bolingcavalry.customizeapplicationevent.listener;

import com.bolingcavalry.customizeapplicationevent.util.Utils;
import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Service;

/**
 * @Description : 自定義的系統廣播監聽器，接收所有型別的訊息
 * @Author : zq2599@gmail.com
 * @Date : 2018-08-15 14:53
 */
@Service
public class AllEventListener implements ApplicationListener<applicationevent>{

@Override
    public void onApplicationEvent(ApplicationEvent event) {
	//為了便於瞭解呼叫棧，在日誌中列印當前堆疊
        Utils.printTrack("onApplicationEvent : " + event);
    }
}
```

- 第二個監聽類在泛型中定義的型別是CustomizeEvent，即只接收CustomizeEvent型別的訊息；

```java
package com.bolingcavalry.customizeapplicationevent.listener;

import com.bolingcavalry.customizeapplicationevent.event.CustomizeEvent;
import com.bolingcavalry.customizeapplicationevent.util.Utils;
import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Service;

/**
 * @Description : 自定義的系統廣播監聽器，只接受CustomizeEvent型別的訊息
 * @Author : zq2599@gmail.com
 * @Date : 2018-08-15 14:53
 */
@Service
public class CustomizeEventListener implements ApplicationListener<customizeevent>{

@Override
    public void onApplicationEvent(CustomizeEvent event) {
	//為了便於瞭解呼叫棧，在日誌中列印當前堆疊    
        Utils.printTrack("onApplicationEvent : " + event);
    }
}
```

- 把工程執行起來，先見到CustomizePublisher被注入ApplicationEventPublisher物件的日誌，然後看到AllEventListener收到廣播後列印的日誌，如下所示，可透過日誌中的堆疊資訊印證我們之前看過的廣播監聽相關原始碼：

```shell
2018-08-16 18:35:15.656 INFO 7864 --- [ main] c.b.c.util.Utils : applicationEventPublisher is set : org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext@37e547da: startup date [Thu Aug 16 18:35:14 CST 2018]; root of context hierarchy
************************************************************
java.lang.Thread.getStackTrace() 1,556 > org.springframework.boot.autoconfigure.web.servlet.error.BasicErrorController.error(javax.servlet.http.HttpServletRequest)
2018-08-16 18:35:15.925 INFO 7864 --- [ main] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/error],produces=[text/html]}" onto public org.springframework.web.servlet.ModelAndView org.springframework.boot.autoconfigure.web.servlet.error.BasicErrorController.errorHtml(javax.servlet.http.HttpServletRequest,javax.servlet.http.HttpServletResponse)
2018-08-16 18:35:15.945 INFO 7864 --- [ main] o.s.w.s.handler.SimpleUrlHandlerMapping : Mapped URL path [/webjars/**] onto handler of type [class org.springframework.web.servlet.resource.ResourceHttpRequestHandler]
2018-08-16 18:35:15.946 INFO 7864 --- [ main] o.s.w.s.handler.SimpleUrlHandlerMapping : Mapped URL path [/**] onto handler of type [class org.springframework.web.servlet.resource.ResourceHttpRequestHandler]
2018-08-16 18:35:16.059 INFO 7864 --- [ main] o.s.j.e.a.AnnotationMBeanExporter : Registering beans for JMX exposure on startup
2018-08-16 18:35:16.069 INFO 7864 --- [ main] c.b.c.util.Utils : onApplicationEvent : org.springframework.context.event.ContextRefreshedEvent[source=org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext@37e547da: startup date [Thu Aug 16 18:35:14 CST 2018]; root of context hierarchy]
************************************************************
java.lang.Thread.getStackTrace() 1,556 [學習路上，你不孤單，欣宸原創一路相伴...](http://blog.itpub.net/70017844/)</customizeevent></applicationevent></applicationlistener></applicationlistener></applicationlistener></applicationlistener>

spring4.1.8擴充套件實戰之三：廣播與監聽

相關文章