前言
最近公司在重构广告系统，其中核心的打包功由广告系统调用，即对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
