前言
最近公司在重构广告系统，其中核心的打包功由广告系统调用，即对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://HdhCmsTestcnblogs测试数据/jy107600/p/10034857.html
查看更多关于Spring的事件监听机制示例详解的详细内容...