`
yourenyouyu2008
  • 浏览: 287592 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

详解Spring事件驱动模型2

 
阅读更多

http://jinnianshilongnian.iteye.com/blog/1902886

事件驱动模型简介

事件驱动模型也就是我们常说的观察者,或者发布-订阅模型;理解它的几个关键点:

  1. 首先是一种对象间的一对多的关系;最简单的如交通信号灯,信号灯是目标(一方),行人注视着信号灯(多方);
  2. 当目标发送改变(发布),观察者(订阅者)就可以接收到改变;
  3. 观察者如何处理(如行人如何走,是快走/慢走/不走,目标不会管的),目标无需干涉;所以就松散耦合了它们之间的关系。

 

 

接下来先看一个用户注册的例子:



用户注册成功后,需要做这么多事:

1、加积分

2、发确认邮件

3、如果是游戏帐户,可能赠送游戏大礼包

4、索引用户数据

…………

问题:

  1. UserService和其他Service耦合严重,增删功能比较麻烦;
  2. 有些功能可能需要调用第三方系统,如增加积分/索引用户,速度可能比较慢,此时需要异步支持;这个如果使用Spring,可以轻松解决,后边再介绍;

 

从如上例子可以看出,应该使用一个观察者来解耦这些Service之间的依赖关系,如图:


 

增加了一个Listener来解耦UserService和其他服务,即注册成功后,只需要通知相关的监听器,不需要关系它们如何处理。增删功能非常容易。

 

这就是一个典型的事件处理模型/观察者,解耦目标对象和它的依赖对象,目标只需要通知它的依赖对象,具体怎么处理,依赖对象自己决定。比如是异步还是同步,延迟还是非延迟等。

 

上边其实也使用了DIP(依赖倒置原则),依赖于抽象,而不是具体。

 

还是就是使用了IoC思想,即以前主动去创建它依赖的Service,现在只是被动等待别人注册进来。

 

 

其他的例子还有如GUI中的按钮和动作的关系,按钮和动作本身都是一种抽象,每个不同的按钮的动作可能不一样;如“文件-->新建”打开新建窗口;点击“关闭”按钮关闭窗口等等。

 

主要目的是:松散耦合对象间的一对多的依赖关系,如按钮和动作的关系;

 

如何实现呢?面向接口编程(即面向抽象编程),而非面向实现。即按钮和动作可以定义为接口,这样它俩的依赖是最小的(如在Java中,没有比接口更抽象的了)。

 

有朋友会问,我刚开始学的时候也是这样:抽象类不也行吗?记住一个原则:接口目的是抽象,抽象类目的是复用;所以如果接触过servlet/struts2/spring等框架,大家都应该知道:

  • Servlet<-----GenericServlet<-----HttpServlet<------我们自己的
  • Action<------ActionSupport<------我们自己的
  • DaoInterface<------××DaoSupport<-----我们自己的

从上边大家应该能体会出接口、抽象类的主要目的了。现在想想其实很简单。

 

在Java中接口还一个非常重要的好处:接口是可以多实现的,类/抽象类只能单继承,所以使用接口可以非常容易扩展新功能(还可以实现所谓的mixin),类/抽象类办不到

 

Java GUI事件驱动模型/观察者 

扯远了,再来看看Java GUI世界里的事件驱动模型吧:

 

如果写过AWT/Swing程序,应该知道其所有组件都继承自java.awt.Component抽象类,其内部提供了 addXXXListener(XXXListener l) 注册监听器的方法,即Component与实际动作之间依赖于XXXListener抽象。

 

比如获取焦点事件,很多组件都可以有这个事件,是我们知道组件获取到焦点后需要一个处理,虽然每个组件如何处理是特定的(具体的),但我们可以抽象 一个FocusListener,让所有具体实现它然后提供具体动作,这样组件只需依赖于FocusListener抽象,而不是具体。

 

还有如java.awt.Button,提供了一个addActionListener(ActionListener l),用于注册点击后触发的ActionListener实现。

 

组件是一个抽象类,其好处主要是复用,比如复用这些监听器的触发及管理等。

 

JavaBean规范的事件驱动模型/观察者

JavaBean规范提供了JavaBean的PropertyEditorSupport及PropertyChangeListener支持。

 

PropertyEditorSupport就是目标,而PropertyChangeListener就是监听器,大家可以google搜索下,具体网上有很多例子。

 

Java提供的事件驱动模型/观察者抽象

JDK内部直接提供了观察者模式的抽象:

目标:java.util.Observable,提供了目标需要的关键抽象:addObserver/deleteObserver/notifyObservers()等,具体请参考javadoc。

观察者:java.util.Observer,提供了观察者需要的主要抽象:update(Observable o, Object arg),此处还提供了一种推模型(目标主动把数据通过arg推到观察者)/拉模型(目标需要根据o自己去拉数据,arg为null)。

 

因为网上介绍的非常多了,请google搜索了解如何使用这个抽象及推/拉模型的优缺点。

 

接下来是我们的重点:spring提供的事件驱动模型。

 

Spring提供的事件驱动模型/观察者抽象

首先看一下Spring提供的事件驱动模型体系图: 

事件

具体代表者是:ApplicationEvent:

1、其继承自JDK的EventObject,JDK要求所有事件将继承它,并通过source得到事件源,比如我们的AWT事件体系也是继承自它;

2、系统默认提供了如下ApplicationEvent事件实现:


只有一个ApplicationContextEvent,表示ApplicationContext容器事件,且其又有如下实现:

  • ContextStartedEvent:ApplicationContext启动后触发的事件;(目前版本没有任何作用)
  • ContextStoppedEvent:ApplicationContext停止后触发的事件;(目前版本没有任何作用)
  • ContextRefreshedEvent:ApplicationContext初始化或刷新完成后触发的事件;(容器初始化完成后调用)
  • ContextClosedEvent:ApplicationContext关闭后触发的事件;(如web容器关闭时自动会触发spring容 器的关闭,如果是普通java应用,需要调用ctx.registerShutdownHook();注册虚拟机关闭时的钩子才行)

注:org.springframework.context.support.AbstractApplicationContext抽象类实现 了LifeCycle的start和stop回调并发布ContextStartedEvent和ContextStoppedEvent事件;但是无任 何实现调用它,所以目前无任何作用。

 

目标(发布事件者)

具体代表者是:ApplicationEventPublisher及ApplicationEventMulticaster,系统默认提供了如下实现:

1、 ApplicationContext接口继承了ApplicationEventPublisher,并在 AbstractApplicationContext实现了具体代码,实际执行是委托给ApplicationEventMulticaster(可以 认为是多播):

Java代码  收藏代码
  1. public void publishEvent(ApplicationEvent event) {  
  2.     //省略部分代码  
  3.     }  
  4.     getApplicationEventMulticaster().multicastEvent(event);  
  5.     if (this.parent != null) {  
  6.         this.parent.publishEvent(event);  
  7.     }  
  8. }  

我们常用的ApplicationContext都继承自AbstractApplicationContext,如ClassPathXmlApplicationContext、XmlWebApplicationContext等。所以自动拥有这个功能。

 

2、ApplicationContext自动到本地容器里找一个名字为”“的ApplicationEventMulticaster实现,如果 没有自己new一个SimpleApplicationEventMulticaster。其中 SimpleApplicationEventMulticaster发布事件的代码如下:

Java代码  收藏代码
  1. public void multicastEvent(final ApplicationEvent event) {  
  2.     for (final ApplicationListener listener : getApplicationListeners(event)) {  
  3.         Executor executor = getTaskExecutor();  
  4.         if (executor != null) {  
  5.             executor.execute(new Runnable() {  
  6.                 public void run() {  
  7.                     listener.onApplicationEvent(event);  
  8.                 }  
  9.             });  
  10.         }  
  11.         else {  
  12.             listener.onApplicationEvent(event);  
  13.         }  
  14.     }  
  15. }  

 大家可以看到如果给它一个executor(java.util.concurrent.Executor),它就可以异步支持发布事件了。佛则就是通过发送。

 

所以我们发送事件只需要通过ApplicationContext.publishEvent即可,没必要再创建自己的实现了。除非有必要。 

 

监听器

具体代表者是:ApplicationListener

1、其继承自JDK的EventListener,JDK要求所有监听器将继承它,比如我们的AWT事件体系也是继承自它;

2、ApplicationListener接口:

Java代码  收藏代码
  1. public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {  
  2.     void onApplicationEvent(E event);  
  3. }  

其只提供了onApplicationEvent方法,我们需要在该方法实现内部判断事件类型来处理,也没有提供按顺序触发监听器的语义,所以Spring提供了另一个接口,SmartApplicationListener:

Java代码  收藏代码
  1. public interface SmartApplicationListener extends ApplicationListener<ApplicationEvent>, Ordered {  
  2.         //如果实现支持该事件类型 那么返回true  
  3.     boolean supportsEventType(Class<? extends ApplicationEvent> eventType);  
  4.     
  5.         //如果实现支持“目标”类型,那么返回true  
  6.     boolean supportsSourceType(Class<?> sourceType);  
  7.          
  8.         //顺序,即监听器执行的顺序,值越小优先级越高  
  9.         int getOrder();  
  10. }  

该接口可方便实现去判断支持的事件类型、目标类型,及执行顺序。 

 

Spring事件机制的简单例子

本例子模拟一个给多个人发送内容(类似于报纸新闻)的例子。

1、定义事件

Java代码  收藏代码
  1. package com.sishuok.hello;  
  2. import org.springframework.context.ApplicationEvent;  
  3. public class ContentEvent extends ApplicationEvent {  
  4.     public ContentEvent(final String content) {  
  5.         super(content);  
  6.     }  
  7. }  

非常简单,如果用户发送内容,只需要通过构造器传入内容,然后通过getSource即可获取。

 

2、定义无序监听器

之所以说无序,类似于AOP机制,顺序是无法确定的。

Java代码  收藏代码
  1. package com.sishuok.hello;  
  2. import org.springframework.context.ApplicationEvent;  
  3. import org.springframework.context.ApplicationListener;  
  4. import org.springframework.stereotype.Component;  
  5. @Component  
  6. public class LisiListener implements ApplicationListener<ApplicationEvent> {  
  7.     @Override  
  8.     public void onApplicationEvent(final ApplicationEvent event) {  
  9.         if(event instanceof ContentEvent) {  
  10.             System.out.println("李四收到了新的内容:" + event.getSource());  
  11.         }  
  12.     }  
  13. }  

1、使用@Compoent注册Bean即可;

2、在实现中需要判断event类型是ContentEvent才可以处理;

 

更简单的办法是通过泛型指定类型,如下所示

Java代码  收藏代码
  1. package com.sishuok.hello;  
  2. import org.springframework.context.ApplicationListener;  
  3. import org.springframework.stereotype.Component;  
  4. @Component  
  5. public class ZhangsanListener implements ApplicationListener<ContentEvent> {  
  6.     @Override  
  7.     public void onApplicationEvent(final ContentEvent event) {  
  8.         System.out.println("张三收到了新的内容:" + event.getSource());  
  9.     }  
  10. }  

 

3、定义有序监听器 

实现SmartApplicationListener接口即可。

Java代码  收藏代码
  1. package com.sishuok.hello;  
  2. import org.springframework.context.ApplicationEvent;  
  3. import org.springframework.context.event.SmartApplicationListener;  
  4. import org.springframework.stereotype.Component;  
  5.   
  6. @Component  
  7. public class WangwuListener implements SmartApplicationListener {  
  8.   
  9.     @Override  
  10.     public boolean supportsEventType(final Class<? extends ApplicationEvent> eventType) {  
  11.         return eventType == ContentEvent.class;  
  12.     }  
  13.     @Override  
  14.     public boolean supportsSourceType(final Class<?> sourceType) {  
  15.         return sourceType == String.class;  
  16.     }  
  17.     @Override  
  18.     public void onApplicationEvent(final ApplicationEvent event) {  
  19.         System.out.println("王五在孙六之前收到新的内容:" + event.getSource());  
  20.     }  
  21.     @Override  
  22.     public int getOrder() {  
  23.         return 1;  
  24.     }  
  25. }  
Java代码  收藏代码
  1. package com.sishuok.hello;  
  2. import org.springframework.context.ApplicationEvent;  
  3. import org.springframework.context.event.SmartApplicationListener;  
  4. import org.springframework.stereotype.Component;  
  5.   
  6. @Component  
  7. public class SunliuListener implements SmartApplicationListener {  
  8.   
  9.     @Override  
  10.     public boolean supportsEventType(final Class<? extends ApplicationEvent> eventType) {  
  11.         return eventType == ContentEvent.class;  
  12.     }  
  13.   
  14.     @Override  
  15.     public boolean supportsSourceType(final Class<?> sourceType) {  
  16.         return sourceType == String.class;  
  17.     }  
  18.   
  19.     @Override  
  20.     public void onApplicationEvent(final ApplicationEvent event) {  
  21.         System.out.println("孙六在王五之后收到新的内容:" + event.getSource());  
  22.     }  
  23.   
  24.     @Override  
  25.     public int getOrder() {  
  26.         return 2;  
  27.     }  
  28. }  
  1. supportsEventType:用于指定支持的事件类型,只有支持的才调用onApplicationEvent;
  2. supportsSourceType:支持的目标类型,只有支持的才调用onApplicationEvent;
  3. getOrder:即顺序,越小优先级越高

 

4、测试 

4.1、配置文件

Java代码  收藏代码
  1. <context:component-scan base-package="com.sishuok"/>  

 就一句话,自动扫描注解Bean。

 

4.2、测试类

Java代码  收藏代码
  1. package com.sishuok;  
  2. import com.sishuok.hello.ContentEvent;  
  3. import org.junit.Test;  
  4. import org.junit.runner.RunWith;  
  5. import org.springframework.beans.factory.annotation.Autowired;  
  6. import org.springframework.context.ApplicationContext;  
  7. import org.springframework.test.context.ContextConfiguration;  
  8. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;  
  9.   
  10. @RunWith(SpringJUnit4ClassRunner.class)  
  11. @ContextConfiguration(locations={"classpath:spring-config-hello.xml"})  
  12. public class HelloIT {  
  13.   
  14.     @Autowired  
  15.     private ApplicationContext applicationContext;  
  16.     @Test  
  17.     public void testPublishEvent() {  
  18.         applicationContext.publishEvent(new ContentEvent("今年是龙年的博客更新了"));  
  19.     }  
  20.   
  21. }  

接着会输出:

Java代码  收藏代码
  1. 王五在孙六之前收到新的内容:今年是龙年的博客更新了  
  2. 孙六在王五之后收到新的内容:今年是龙年的博客更新了  
  3. 李四收到了新的内容:今年是龙年的博客更新了  
  4. 张三收到了新的内容:今年是龙年的博客更新了  

   

一个简单的测试例子就演示完毕,而且我们使用spring的事件机制去写相关代码会非常简单。

 

Spring事件机制实现之前提到的注册流程

具体请下载源代码参考com.sishuok.register包里的代码。此处贴一下源码结构:


  

这里讲解一下Spring对异步事件机制的支持,实现方式有两种:

 

1、全局异步

即只要是触发事件都是以异步执行,具体配置(spring-config-register.xml)如下:

 

Java代码  收藏代码
  1. <task:executor id="executor" pool-size="10" />  
  2. <!-- 名字必须是applicationEventMulticaster和messageSource是一样的,默认找这个名字的对象 -->  
  3. <!-- 名字必须是applicationEventMulticaster,因为AbstractApplicationContext默认找个 -->  
  4. <!-- 如果找不到就new一个,但不是异步调用而是同步调用 -->  
  5. <bean id="applicationEventMulticaster" class="org.springframework.context.event.SimpleApplicationEventMulticaster">  
  6.     <!-- 注入任务执行器 这样就实现了异步调用(缺点是全局的,要么全部异步,要么全部同步(删除这个属性即是同步))  -->  
  7.     <property name="taskExecutor" ref="executor"/>  
  8. </bean>  

通过注入taskExecutor来完成异步调用。具体实现可参考之前的代码介绍。这种方式的缺点很明显:要么大家都是异步,要么大家都不是。所以不推荐使用这种方式。

 

2、更灵活的异步支持

spring3提供了@Aync注解来完成异步调用。此时我们可以使用这个新特性来完成异步调用。不仅支持异步调用,还支持简单的任务调度,比如我的项目就去掉Quartz依赖,直接使用spring3这个新特性,具体可参考spring-config.xml

 

2.1、开启异步调用支持

 

Java代码  收藏代码
  1. <!-- 开启@AspectJ AOP代理 -->  
  2. <aop:aspectj-autoproxy proxy-target-class="true"/>  
  3.   
  4. <!-- 任务调度器 -->  
  5. <task:scheduler id="scheduler" pool-size="10"/>  
  6.   
  7. <!-- 任务执行器 -->  
  8. <task:executor id="executor" pool-size="10"/>  
  9.   
  10. <!--开启注解调度支持 @Async @Scheduled-->  
  11. <task:annotation-driven executor="executor" scheduler="scheduler" proxy-target-class="true"/>  

 

 

2.2、配置监听器让其支持异步调用

Java代码  收藏代码
  1. @Component  
  2. public class EmailRegisterListener implements ApplicationListener<RegisterEvent> {  
  3.     @Async  
  4.     @Override  
  5.     public void onApplicationEvent(final RegisterEvent event) {  
  6.         System.out.println("注册成功,发送确认邮件给:" + ((User)event.getSource()).getUsername());  
  7.     }  
  8. }  

使用@Async注解即可,非常简单。 

 

这样不仅可以支持通过调用,也支持异步调用,非常的灵活,实际应用推荐大家使用这种方式。

 

 

通过如上,大体了解了Spring的事件机制,可以使用该机制非常简单的完成如注册流程,而且对于比较耗时的调用,可以直接使用Spring自身的异步支持来优化。

分享到:
评论

相关推荐

    详解Spring事件驱动模型

    Spring框架是Java开发中广泛应用的一个开源框架,它提供了一种事件驱动模型来增强应用程序的组件之间的通信。在本文中,我们将深入探讨Spring事件驱动模型,理解其工作原理,并通过源码分析来深化认识。 首先,...

    spring boot 领域驱动设计Demo.zip

    《Spring Boot领域驱动设计实战详解》 在当前的软件开发领域,Spring Boot因其简洁的配置、快速的开发体验以及强大的生态系统,已经成为了Java后端开发的首选框架。然而,随着项目规模的扩大,如何有效地组织代码,...

    spring MVC配置详解

    Spring MVC 配置详解 Spring MVC 是一个基于 DispatcherServlet 的 MVC 框架,它是当前主流的 Web 框架之一。要想灵活运用 Spring MVC 来应对大多数的 Web 开发,就必须要掌握它的配置及原理。 一、Spring MVC ...

    《精通Spring 2.x-企业应用开发详解》chapter22.rar

    《精通Spring 2.x-企业应用开发详解》的第22章主要涵盖了Spring框架在企业级应用中的高级特性和实践技巧。Spring作为一个轻量级、全面的Java应用程序框架,为开发者提供了众多强大的功能,包括依赖注入(DI)、面向...

    Spring MVC 框架搭建及详解

    Spring MVC 是一个强大的、灵活的用于构建 Web 应用程序的模型-视图-控制器(MVC)框架。它允许开发者将业务逻辑与表现层分离,从而提高代码的可维护性和可测试性。本文将深入讲解如何搭建 Spring MVC 框架,并探讨...

    多图详解Spring框架的设计理念与设计模式

    - **作用**:Spring框架利用观察者模式实现事件驱动的模型。 - **应用场景**:如在Spring MVC中处理异步请求。 #### 四、总结 Spring框架之所以能够在众多框架中脱颖而出,与其清晰的设计理念和巧妙的设计模式...

    精通spring2.x企业应用开发详解

    《精通Spring 2.x企业应用开发详解》是一本深度探讨Spring框架在企业级应用开发中的实践书籍,其源代码部分包含多个章节的实例,旨在帮助读者深入理解和掌握Spring的核心特性和实际运用。以下是对各章节内容的详细...

    Struts1.2+Spring1.2+Hibernate2.0搭建详解

    Struts1.2、Spring1.2和Hibernate2.0是经典...然而,需要注意的是,Struts1.2、Spring1.2和Hibernate2.0都已较为老旧,现在更推荐使用更新的版本,如Struts2、Spring Boot和Hibernate5,以获得更好的性能和最新的特性。

    jsf2+spring sample

    JavaServer Faces 2(简称JSF2)是Java平台上的一个企业级的用户界面框架,它为构建基于Web的应用程序提供了组件化、事件驱动的模型。而Spring框架则是Java后端开发的核心框架,以其依赖注入(DI)和面向切面编程...

    spring源码中英文注释

    8. **事件驱动**:Spring框架允许应用在特定事件(如bean的初始化或销毁)发生时进行响应。`ApplicationEvent`和`ApplicationListener`接口是实现事件驱动的关键。 9. **国际化与本地化**:Spring提供了`...

    Spring in action 2nd

    2. **丰富的实践案例**:书中提供了大量实用的代码示例,帮助读者更好地理解Spring框架的使用方法。 3. **幽默风趣的语言风格**:作者采用轻松幽默的语言风格,使得阅读过程更加愉悦,有助于提高学习效率。 4. **高...

    spring2.5 mvc_ibatis2

    《Spring 2.5 MVC与iBatis 2整合详解》 在Web开发领域,Spring框架以其强大的功能和灵活性备受开发者喜爱。Spring 2.5版本是Spring发展史上的一个重要里程碑,它引入了许多新特性,使得开发更加高效。同时,iBatis...

    Spring——jar包详解

    7. **Spring Test**:提供了一组工具,用于测试Spring配置和Spring驱动的应用程序。 了解了Spring的基本模块后,我们来看看如何在实际项目中使用jar包。通常,我们需要在项目的类路径下包含相应的Spring库,例如`...

    SpringMVC框架搭建及详解.pdf

    2. 控制器接收请求,并调用模型的业务逻辑。 3. 模型执行业务逻辑,并将结果返回给控制器。 4. 控制器将结果返回给视图。 5. 视图将结果显示给用户。 五、 结论 本文详细介绍了Spring MVC框架的搭建及详解,并对其...

    spring框架技术详解及使用指导

    《Spring框架技术详解及使用指导》是一本深入探讨Spring Framework的开发指南,旨在帮助开发者全面理解和熟练运用这一Java企业级应用开发的重要工具。Spring Framework以其模块化、灵活的依赖注入和面向切面编程等...

    《精通Spring 2.x-企业应用开发详解》chapter17

    《精通Spring 2.x - 企业应用开发详解》是针对Spring框架深入学习的一本书,特别关注Spring 2.x版本的相关内容。本章17可能是关于Spring在企业级应用中的高级特性和实践,如集成其他技术栈,提升系统性能和可维护性...

    Spring中ApplicationContext对事件传递

    这里需要注意的是,由于Spring IoC容器中的事件模型是一种简单的、粗粒度的监听模型,即所有的监听器都会接收到同一事件,因此通常需要在监听器内部进行事件类型的检查,以决定是否需要处理该事件。 ##### 3. 事件...

    spring入门教程书籍

    7. **MVC框架**:详解Spring MVC的架构,控制器、视图解析、模型-视图-控制器模式的应用。 8. **Spring测试**:教授如何使用Spring Test和JUnit进行单元测试和集成测试。 9. **Web服务**:包括RESTful服务的实现,...

Global site tag (gtag.js) - Google Analytics