前言
最近公司在重構廣告系統，其中核心的打包功由廣告系統調用，即對apk打包的調用和打包完成之后的回調，需要提供相應的接口給廣告系統。因此，為了將apk打包的核心流程和對接廣告系統的業務解耦，利用了spring的事件監聽特性來滿足需求。以下說明spring的事件機制的相關內容。
首先spring事件分為事件發布者(eventpublisher)、事件監聽者(eventlistener),還包括一個事件廣播者(這個是spring實現相關，這一節不討論)。使用spring事件機制，需要自定義事件發布者和監聽者。
1.觀察者模式
spring的事件監聽（也稱事件驅動）是觀察者模式的一種實現，比較常見的有發布-訂閱模型。通常我們利用消息隊列來實現不同系統之間的解耦，如用戶注冊完成后，可以向消息隊列發布一條消息，然后訂閱了此topic的子系統（如郵件服務，積分服務）收到發布的消息之后，就會做相應的處理。這樣做的好處是避免了在注冊服務里耦合其他服務的代碼，并且，執行子系統的業務將會異步執行，互不影響。下圖是一個經典的觀察者模式的結構。
以下為上述觀察者模式的java簡單實現：
（1）subject.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
|
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
|
1
2
3
4
5
6
7
8
9
10
|
package observerpattern;/** * created by jy on 2018/11/28. */public interface observer { // 抽象出的更新行為 public void update(string state);} |
(3)concretesubject.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
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
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
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
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
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）。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
@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：
|
1
2
3
4
5
6
7
8
9
10
|
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：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
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 是怎么廣播事件的，由代碼可知，在線程池不為空的情況下，異步發布特定類型的事件。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
@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(),實現了事件的發布。
|
1
2
3
4
5
6
7
8
|
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中事件發布的機制。
總結
以上就是這篇文章的全部內容了，希望本文的內容對大家的學習或者工作具有一定的參考學習價值，如果有疑問大家可以留言交流，謝謝大家對服務器之家的支持。
原文鏈接：https://www.cnblogs.com/jy107600/p/10034857.html
