Spring的事件監聽及應用
最近公司在重構廣告系統，其中核心的打包功由廣告系統呼叫，即對apk打包的呼叫和打包完成之後的回撥，需要提供相應的介面給廣告系統。因此，為了將apk打包的核心流程和對接廣告系統的業務解耦，利用了spring的事件監聽特性來滿足需求。以下說明spring的事件機制的相關內容。
1.觀察者模式
Spring的事件監聽（也稱事件驅動）是觀察者模式的一種實現，比較常見的有釋出-訂閱模型。通常我們利用訊息佇列來實現不同系統之間的解耦，如使用者註冊完成後，可以向訊息佇列釋出一條訊息，然後訂閱了此topic的子系統（如郵件服務，積分服務）收到釋出的訊息之後，就會做相應的處理。這樣做的好處是避免了在註冊服務裡耦合其他服務的程式碼，並且，執行子系統的業務將會非同步執行，互不影響。下圖是一個經典的觀察者模式的結構。
以下為上述觀察者模式的java簡單實現：
（1）Subject.java
1 package observerPattern;
2
3 import java.util.ArrayList;
4 import java.util.List;
5
6 /**
7 * Created by jy on 2018/11/28.
8 */
9 public abstract class Subject {
10
11 //維護一個所有觀察者集合
12 private List<Observer> list = new ArrayList<>();
13
14 //新註冊一個觀察者
15 public void attach(Observer observer){
16 list.add(observer);
17 System.out.println("新註冊一個觀察者");
18 }
19
20 //刪除一個已註冊的觀察者
21 public void detach(Observer observer){
22 list.remove(observer);
23 System.out.println("刪除一個已註冊的觀察者");
24 }
25
26
27 //通知所有已經註冊的觀察者
28 public void notifyObservers(String state){
29 for (int i = 0; i < list.size(); i++) {
30 list.get(i).update(state);
31 }
32 }
33 }
(2)Observer.java
1 package observerPattern;
2
3 /**
4 * Created by jy on 2018/11/28.
5 */
6 public interface Observer {
7
8 // 抽象出的更新行為
9 public void update(String state);
10 }
(3)ConcreteSubject.java
1 package observerPattern;
2
3 /**
4 * Created by jy on 2018/11/28.
5 */
6 public class ConcreteSubject extends Subject{
7
8 //真實主題內維護一個狀態
9 private String state;
10
11 public String getState() {
12 return state;
13 }
14
15 public void change(String state){
16 this.state = state;
17 System.out.println("真實主題狀態變化為:"+state);
18 this.notifyObservers(state);
19 }
20 }
(4)ConcreteObserver.java
1 package observerPattern;
2
3 /**
4 * Created by jy on 2018/11/28.
5 */
6 public class ConcreteObserver implements Observer {
7
8 //具體觀察者的狀態
9 private String observerState;
10
11 @Override
12 public void update(String state) {
13 //這裡可以根據傳遞過來的主題的狀態作出相應的業務
14 observerState = state;
15 System.out.println("觀察者的狀態跟著變化為："+observerState);
16 }
17 }
(5)Main.java
1 package observerPattern;
2
3 /**
4 * Created by jy on 2018/11/28.
5 */
6 public class Main {
7 public static void main(String[] args) {
8 //真實主題
9 ConcreteSubject concreteSubject = new ConcreteSubject();
10 //真實觀察者
11 ConcreteObserver concreteObserver = new ConcreteObserver();
12 //觀察者先註冊
13 concreteSubject.attach(concreteObserver);
14
15 //改變真實主題狀態
16 concreteSubject.change("2");
17
18 }
19 }
結果：在執行了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，註冊等方法：
1 @Override
2 public void addApplicationListener(ApplicationListener<?> listener) {
3 Assert.notNull(listener, "ApplicationListener must not be null");
4 //listener傳入持有的一個的applicationEventMulticaster類中
5 if (this.applicationEventMulticaster != null) {
6 this.applicationEventMulticaster.addApplicationListener(listener);
7 }
8 this.applicationListeners.add(listener);
9 }
10
11 //省略部分程式碼
12
13 protected void registerListeners() {
14 // Register statically specified listeners first.
15 for (ApplicationListener<?> listener : getApplicationListeners()) {
16 getApplicationEventMulticaster().addApplicationListener(listener);
17 }
18
19 // Do not initialize FactoryBeans here: We need to leave all regular beans
20 // uninitialized to let post-processors apply to them!
21 String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
22 for (String listenerBeanName : listenerBeanNames) {
23 getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
24 }
25
26 // Publish early application events now that we finally have a multicaster...
27 Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
28 this.earlyApplicationEvents = null;
29 if (earlyEventsToProcess != null) {
30 for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
31 getApplicationEventMulticaster().multicastEvent(earlyEvent);
32 }
33 }
34 }
在AbstractApplicationContext中publishEvent：
1 protected void publishEvent(Object event, @Nullable ResolvableType eventType) {
2 //.....
3 // Multicast right now if possible - or lazily once the multicaster is initialized
4 if (this.earlyApplicationEvents != null) {
5 this.earlyApplicationEvents.add(applicationEvent);
6 }
7 else {
8 getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType); //事件廣播
10 //....
11 }
上面程式碼中的觀察者最終都新增至一個ApplicationEventMulticaster型別的類中，具體的釋出事件的方法都在這個類中去實現的，在AbstractApplicationContext中，會先嚐試從ConfigurableListableBeanFactory中去載入這個類，如果不存在，則會預設new 一個SimpleApplicationEventMulticaster：
1 protected void initApplicationEventMulticaster() {
2 ConfigurableListableBeanFactory beanFactory = getBeanFactory();
3 if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) { //嘗試載入
4 this.applicationEventMulticaster =
5 beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
6 if (logger.isTraceEnabled()) {
7 logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
8 }
9 }
10 else {
11 this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory); //不存在則預設使用SimpleApplicationEventMulticaster
12 beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
看看SimpleApplicationEventMulticaster 是怎麼廣播事件的，由程式碼可知，線上程池不為空的情況下，非同步釋出特定型別的事件。
1 @Override
2 public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
3 ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
4 for (final ApplicationListener<?> listener : getApplicationListeners(event, type)) {
5 Executor executor = getTaskExecutor();
6 if (executor != null) {
7 executor.execute(() -> invokeListener(listener, event));
8 }
9 else {
10 invokeListener(listener, event);
11 }
12 }
13 //....
將invokeListener方法點選到最後，發現呼叫了listener的onApplicationEvent(),實現了事件的釋出。
1 private void doInvokeListener(ApplicationListener listener, ApplicationEvent event) {
2 try {
3 listener.onApplicationEvent(event);
4 }
5 catch (ClassCastException ex) {
6 //....
7 }
8 }
（3）事件訂閱者（ApplicationListener）：實現這個介面，就可以監聽ApplicationListener釋出的特定的事件。
實現ApplicationListener這個介面，重寫onApplicationEvent()方法，來處理監聽到的ApplicationEvent，這裡可以監聽特定型別的事件。
3. 基於註解的事件監聽
spring也為釋出者和監聽者提供了相應的註解支援，只需要在對應的觀察者類的對應方法上加上@EventListener：
對於釋出者，可以直接在service通過@Autowired注入ApplicationEventPublisher。
4.推廣時間
同學，你造嗎？阿里雲，騰訊雲產品白菜價啦！雲伺服器最低不到300元/年。這裡有一份雲端計算優惠活動列表，來不及解釋了，趕緊上車！