Spring的事件监听机制示例详解
这篇文章主要给大家介绍了关于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中事件发布的机制。
总结
以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对CodeAE代码之家的支持。
原文链接：https://www.cnblogs.com/jy107600/p/10034857.html
http://www.zzvips.com/article/171341.html
页:
[1]