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中事件发布的机制。

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对的支持。