這篇文章主要給大家介紹了關於Spring的事件監聽機制的相關資料，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨着小編來一起學習學習吧
前言
最近公司在重構廣告系統，其中核心的打包功由廣告系統調用，即對apk打包的調用和打包完成之後的回調，需要提供相應的接口給廣告系統。因此，爲了將apk打包的核心流程和對接廣告系統的業務解耦，利用了spring的事件監聽特性來滿足需求。以下說明spring的事件機制的相關內容。
首先spring事件分爲事件發佈者(EventPublisher)、事件監聽者(EventListener),還包括一個事件廣播者(這個是spring實現相關，這一節不討論)。使用spring事件機制，需要自定義事件發佈者和監聽者。
1.觀察者模式
Spring的事件監聽（也稱事件驅動）是觀察者模式的一種實現，比較常見的有發佈-訂閱模型。通常我們利用消息隊列來實現不同系統之間的解耦，如用戶註冊完成後，可以向消息隊列發佈一條消息，然後訂閱了此topic的子系統（如郵件服務，積分服務）收到發佈的消息之後，就會做相應的處理。這樣做的好處是避免了在註冊服務裏耦合其他服務的代碼，並且，執行子系統的業務將會異步執行，互不影響。下圖是一個經典的觀察者模式的結構。
以下爲上述觀察者模式的java簡單實現：
（1）Subject.java
package observerPattern;
import java.util.ArrayList;
import java.util.List;
/**
* Created by jy on 2018/11/28.
*/
public abstract class Subject {
//維護一個所有觀察者集合
private List<Observer> list = new ArrayList<>();
//新註冊一個觀察者
public void attach(Observer observer){
list.add(observer);
System.out.println("新註冊一個觀察者");
}
//刪除一個已註冊的觀察者
public void detach(Observer observer){
list.remove(observer);
System.out.println("刪除一個已註冊的觀察者");
}
//通知所有已經註冊的觀察者
public void notifyObservers(String state){
for (int i = 0; i < list.size(); i++) {
list.get(i).update(state);
}
}
}
(2)Observer.java
package observerPattern;
/**
* Created by jy on 2018/11/28.
*/
public interface Observer {
// 抽象出的更新行爲
public void update(String state);
}
(3)ConcreteSubject.java
package observerPattern;
/**
* Created by jy on 2018/11/28.
*/
public class ConcreteSubject extends Subject{
//真實主題內維護一個狀態
private String state;
public String getState() {
return state;
}
public void change(String state){
this.state = state;
System.out.println("真實主題狀態變化爲:"+state);
this.notifyObservers(state);
}
}
(4)ConcreteObserver.java
package observerPattern;
/**
* Created by jy on 2018/11/28.
*/
public class ConcreteObserver implements Observer {
//具體觀察者的狀態
private String observerState;
@Override
public void update(String state) {
//這裏可以根據傳遞過來的主題的狀態作出相應的業務
observerState = state;
System.out.println("觀察者的狀態跟着變化爲："+observerState);
}
}
(5)Main.java
package observerPattern;
/**
* Created by jy on 2018/11/28.
*/
public class Main {
public static void main(String[] args) {
//真實主題
ConcreteSubject concreteSubject = new ConcreteSubject();
//真實觀察者
ConcreteObserver concreteObserver = new ConcreteObserver();
//觀察者先註冊
concreteSubject.attach(concreteObserver);
//改變真實主題狀態
concreteSubject.change("2");
}
}
結果：在執行了main方法之後，我們可以看到控制檯輸出結果，表明，真實觀察者的狀態是會根據真實主題的狀態變化而變化的：
2. Spring事件監聽
spring也對事件驅動模型提供了支持，該模型主要由三部分組成：
（1） 事件（ApplicationEvent）：繼承了jdk的EventObject，在spring項目中可以繼承ApplicationEvent，來自定義自己的事件。
spring容器內部對ApplicationEvent有着下面幾個實現，通過名字可以很清楚事件所描述的行爲。
（2）發佈者（ApplicationEventPublisher）：實現這個接口，就可以使得spring組件有發佈事件的能力。
可以看到，ApplicationContext實現了此接口，因此，可以spring組件可以通過實現ApplicationContextAware接口，注入ApplicationContext，然後，通過ApplicationContext的publishEvent()方法來實現事件傳播，
當然，也可以直接實現ApplicationEventPublisher接口，重寫publishEvent()方法，同樣可以實現事件傳播。
通過閱讀源碼發現，在AbstractApplicationContext類中，定義了針對觀察者的增加，get，註冊等方法。下面代碼中的addApplicationListener()是向ApplicationEventMulticaster類中維護的一個set中添加listener。這個set存儲了該發佈者所有的觀察者（listener）。
@Override
public void addApplicationListener(ApplicationListener<?> listener) {
Assert.notNull(listener, "ApplicationListener must not be null");
//listener傳入持有的一個的applicationEventMulticaster類中
if (this.applicationEventMulticaster != null) {
this.applicationEventMulticaster.addApplicationListener(listener);
}
this.applicationListeners.add(listener);
}
//省略部分代碼
protected void registerListeners() {
// Register statically specified listeners first.
for (ApplicationListener<?> listener : getApplicationListeners()) {
getApplicationEventMulticaster().addApplicationListener(listener);
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let post-processors apply to them!
String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
for (String listenerBeanName : listenerBeanNames) {
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
}
// Publish early application events now that we finally have a multicaster...
Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
this.earlyApplicationEvents = null;
if (earlyEventsToProcess != null) {
for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
getApplicationEventMulticaster().multicastEvent(earlyEvent);
}
}
}
在AbstractApplicationContext中publishEvent：
protected void publishEvent(Object event, @Nullable ResolvableType eventType) {
//.....
// Multicast right now if possible - or lazily once the multicaster is initialized
if (this.earlyApplicationEvents != null) {
this.earlyApplicationEvents.add(applicationEvent);
}
else {
getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType); //事件廣播
//....
}
具體的發佈事件的方法都在上面提到的ApplicationEventMulticaster這個類型的類中去實現的，在AbstractApplicationContext中，會先嚐試從ConfigurableListableBeanFactory中去加載這個類，如果不存在，則會默認new 一個SimpleApplicationEventMulticaster：
protected void initApplicationEventMulticaster() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) { //嘗試加載
this.applicationEventMulticaster =
beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
if (logger.isTraceEnabled()) {
logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
}
}
else {
this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory); //不存在則默認使用SimpleApplicationEventMulticaster
beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
看看SimpleApplicationEventMulticaster 是怎麼廣播事件的，由代碼可知，在線程池不爲空的情況下，異步發佈特定類型的事件。
@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方法點擊到最後，發現調用了listener的onApplicationEvent(),實現了事件的發佈。
private void doInvokeListener(ApplicationListener listener, ApplicationEvent event) {
try {
listener.onApplicationEvent(event);
}
catch (ClassCastException ex) {
//....
}
}
（3）事件訂閱者（ApplicationListener）：實現這個接口，就可以監聽ApplicationListener發佈的特定的事件。
實現ApplicationListener這個接口，重寫onApplicationEvent()方法，來處理監聽到的ApplicationEvent，這裏可以監聽特定類型的事件。
3. 基於註解的事件監聽
spring也爲發佈者和監聽者提供了相應的註解支持，只需要在對應的觀察者類的對應方法上加上@EventListener：
對於發佈者，可以直接在service通過@Autowired注入ApplicationEventPublisher。
4.小結
文章主要介紹了spring中事件驅動的模型。主要運用了觀察者模式的思想，隨後介紹了spring中事件發佈的機制。
總結
以上就是這篇文章的全部內容了，希望本文的內容對大家的學習或者工作具有一定的參考學習價值，如果有疑問大家可以留言交流，謝謝大家對神馬文庫的支持。