事件Event监听相关——spring的事件监听相关

谁借莪１个温暖的怀抱￠ 2024-04-17 19:48 179阅读 0赞

应用场景：

事件驱动模型简介

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

1、首先是对象间的一对多的关系；最简单的如交通信号灯，信号灯是目标（一方），行人注视着信号灯（多方）；

2、当目标发送改变（发布），观察者（订阅者）就可以接收到改变；

3、观察者如何处理（如行人如何走，是快走/慢走/不走，目标不会管的），目标无需干涉；所以就松散耦合了它们之间的关系。

比分最常见的用户注册之后可能需要做很多操作：

1、加积分

2、发优惠券

3、创建初始化数据等…………

问题：

UserService和其他Service耦合严重，增删功能比较麻烦；
有些功能可能需要调用第三方系统，如增加积分/索引用户，速度可能比较慢，此时需要异步支持。

所以需要解耦这些Service之间的依赖关系。事件监听就是一种最佳的解决方案。

如何实现呢？面向接口编程（即面向抽象编程），而非面向实现。即事件和动作可以定义为接口，这样它俩的依赖是最小的。

在Java中接口还一个非常重要的好处：接口是可以多实现的，类/抽象类只能单继承，所以使用接口可以非常容易扩展新功能。

一、最简单基本的事件机制：

java中的事件机制的参与者有3种角色：

1.event object：事件状态对象，集成java.util.EventObject。用于listener的相应的方法之中，作为参数，一般存在于listerner的方法之中。

2.event listener：对每个明确的事件的发生，都相应地定义一个明确的Java方法。这些方法都集中定义在事件监听者（EventListener）接口中，这个接口要实现 java.util.EventListener。 实现了事件监听者接口中一些或全部方法的类就是事件监听者。

3.event source：具体的事件源，比如说，注册事件，值改变事件，事件源就是event source，要想对这些事件进行响应，就需要注册特定的listener。

示例代码：

1、被监控值改变的对象：

  1. package my.mark.mybaibaoxiang.eventDemo.easyEvent;
  4. /**
  5.  * @author twotiger-wxm.
  6.  * @date 2019-9-11.
  7.  */
  8. public class Door {
  10.     /**==================单例模式begin=================*/
  11.     private final static Door INSTANCE = new Door(new DoorStateListener(),new DoorNameListener());
  12.     //私有化构造函数，不让外部调用。
  13.     private Door(){}
  14.     private Door(DoorStateListener stateListener,DoorNameListener  nameListener){
  15.         this.stateListener= stateListener;
  16.         this.nameListener= nameListener;
  17.     }
  19.     public static Door getInstance(){
  20.         return INSTANCE;
  21.     }
  22.     /**==================单例模式end=================*/
  24.     private String state = "";
  25.     private String name = "";
  26.     private DoorStateListener stateListener;
  27.     private DoorNameListener  nameListener;
  29.     public void setState(String newValue) {
  30.         if (state != newValue) {
  31.             state = newValue;
  32.             if (stateListener != null){
  33.                 //注意参数传递
  34.                 DoorEvent event = new DoorEvent(this, "state",newValue);
  35.                 stateListener.doorEvent(event);
  36.             }
  37.         }
  38.     }
  40.     public void setName(String newValue) {
  41.         if (name != newValue) {
  42.             name = newValue;
  43.             if (nameListener != null){
  44.                 DoorEvent event = new DoorEvent(this,"name", newValue);
  45.                 nameListener.doorEvent(event);
  46.             }
  47.         }
  48.     }
  50.     public void setStateListener(DoorStateListener stateListener) {
  51.         this.stateListener = stateListener;
  52.     }
  54.     public void setNameListener(DoorNameListener nameListener) {
  55.         this.nameListener = nameListener;
  56.     }
  58.     public String getState() {
  59.         return state;
  60.     }
  62.     public String getName() {
  63.         return name;
  64.     }
  66. }

2、事件传递对象

  1. package my.mark.mybaibaoxiang.eventDemo.easyEvent;
  3. import java.util.EventObject;
  5. /**
  6.  * @author twotiger-wxm.
  7.  * @date 2019-9-11.
  8.  */
  9. public class DoorEvent extends EventObject {
  10.     private static final long serialVersionUID = 6496098798146410884L;
  12.     private final String key;
  13.     private final String value;
  15.     /**source存放Object对象，传递业务数据对象。*/
  16.     public DoorEvent(Object source,String key,String value) {
  17.         super(source);
  18.         this.key = key;
  19.         this.value = value;
  20.     }
  22.     public String getValue() {
  23.         return value;
  24.     }
  26.     public String getKey() {
  27.         return key;
  28.     }
  29. }

3、两个监听值改变了的监听类

  1. package my.mark.mybaibaoxiang.eventDemo.easyEvent;
  3. import java.util.EventListener;
  5. /**
  6.  * @author twotiger-wxm.
  7.  * @date 2019-9-11.
  8.  */
  9. public class DoorNameListener implements EventListener {
  10.     public void doorEvent(DoorEvent event) {
  11.         Door door = (Door) event.getSource();
  12.         System.out.println("I got a new name,named \"" + door.getName() + "\"");
  13.     }
  14. }
  16. package my.mark.mybaibaoxiang.eventDemo.easyEvent;
  18. import java.util.EventListener;
  20. /**
  21.  * @author twotiger-wxm.
  22.  * @date 2019-9-11.
  23.  */
  24. public class DoorStateListener implements EventListener {
  25.     public void doorEvent(DoorEvent event) {
  26.         if (event.getValue() != null && event.getValue().equals("open")) {
  27.             System.out.println("门1打开");
  28.         } else {
  29.             System.out.println("门1关闭");
  30.         }
  31.     }
  32. }

4、事件触发来源测试类

  1. package my.mark.mybaibaoxiang.eventDemo.easyEvent;
  3. /**
  4.  * 最简单的事件监听模式（某个对象的值改变后做相应操作。）
  5.  * @author twotiger-wxm.
  6.  * @date 2019-9-11.
  7.  */
  8. public class EventTest {
  9.     public static void main(String[] args) {
  11.         Door door = Door.getInstance();
  13.         // 开门
  14.         door.setState("open");
  15.         System.out.println("我已经进来了");
  16.         // 关门
  17.         door.setState("close");
  18.         // 改名
  19.         door.setName("dengzy"); }
  20. }

二、spring的事件Event相关

zuul等很多优秀的源码用到了EventListener。

spring的事件监听有三个部分组成，事件（ApplicationEvent)、监听器(ApplicationListener)和事件发布操作。

1、事件类需要继承ApplicationEvent，代码如下：

  1. package my.mark.mybaibaoxiang.eventDemo.spring;
  3. import org.springframework.context.ApplicationEvent;
  5. /**
  6.  * 自定义spring事件，自定义的业务事件，在自己的业务逻辑里使用：发布、监听执行。
  7.  */
  8. public class WarnEvent extends ApplicationEvent {
  10.     private static final long serialVersionUID = -7344918861434285999L;
  12.     /**
  13.      * 以下自定义参数传需要的业务参数，到监听后执行。
  14.      */
  15.     private String type;
  17.     private String target;
  19.     private String content;
  21.     public WarnEvent(Object source, String type, String target, String content) {
  22.         super(source);
  23.         this.type = type;
  24.         this.target = target;
  25.         this.content = content;
  26.     }
  28.     public String getType() {
  29.         return type;
  30.     }
  32.     public String getTarget() {
  33.         return target;
  34.     }
  36.     public String getContent() {
  37.         return content;
  38.     }
  40. }

事件类是一种很简单的pojo，除了需要继承ApplicationEvent也没什么了，这个类有一个构造方法需要super。super使该事件类中可携带任何数据，比方唯一标识，或者事件源业务数据对象。通过source得到事件源。

2、事件监听类

事件监听器需要实现ApplicationListener接口，这是个泛型接口，泛型类类型就是事件类型，其次需要是spring容器托管的bean，所以这里加了@component，只有一个方法，就是onApplicationEvent。

  1. @Component
  2. public class HelloEventListener implements ApplicationListener<HelloEvent> {
  4.     private static final Logger logger = LoggerFactory.getLogger(HelloEventListener.class);
  6.     @Override
  7.     public void onApplicationEvent(HelloEvent event) {
  8.         logger.info("receive {} say hello!",event.getName());
  9.     }
  10. }

ApplicationListener 接口的定义如下：

  1. @FunctionalInterface
  2. public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {
  4.     /**
  5.      * Handle an application event.
  6.      * @param event the event to respond to
  7.      */
  8.     void onApplicationEvent(E event);
  10. }

它是一个泛型接口，泛型的类型必须是 ApplicationEvent 及其子类，只要实现了这个接口，那么当容器有相应的事件触发时，就能触发 onApplicationEvent 方法。

我们可以直接去监听ApplicationEvent去监听spring的所有事件：

  1. @Component
  2. public class MyApplicationListener implements ApplicationListener<ApplicationEvent> {
  4. @Override
  5. public void onApplicationEvent(ApplicationEvent event) {
  6.   System.out.println("事件触发："+event.getClass().getName());
  7. }
  8. }

或者直接用注解将某个方法变成监听处理器：

  1. @Async
  2.     @EventListener
  3.     public void send(WarnEvent event) {
  4.         try {
  5.             logger.info("===================WarnEvent走了");
  6.             /*SendService sendService = factory.getSendService(event.getType());
  7.             sendService.send(event.getTarget(), event.getContent());*/
  8.         } catch (Exception e) {
  9.             logger.error("消息发送失败! cause by:" + e.getMessage(), e);
  10.         }
  11.     }

EventListener这个注解其实可以接受参数来表示事件源的，有两个参数classes和condition，顾明思议前者是表示哪一个事件类，后者是当满足什么条件是会调用该方法，但其实都可以不用用到，直接在方法上写参数HelloEvent就行。

3、事件发布操作

  1. applicationContext.publishEvent(new WarnEvent(UUID.randomUUID(), type, target, content));

要获取应用上下文applicationContext，可实现implements ApplicationContextAware，通过接口方法获取。

  1. @Override
  2.     public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
  3.         this.applicationContext = applicationContext;
  4.     }

事件发布操作和事件监听后操作默认同步，但如果给监听方法加spring的异步线程注解@Async使用默认线程池或者指定线程池，也可以让变成异步。

三、Spring事件驱动

spring的事件驱动最大的特征是监听器的添加方式，spring一般的添加方式是实现ApplicationListener接口，然后把实现类注册为Bean，spring的上下文初始化的时候会自动扫描路径下的实现ApplicationListener接口的类，然后添加到监听器集合里面，发布事件的时候会通知所有的监听器（同老虎的监听设计一样），这一切要依赖spring的容器管理Bean的功能。

四、监听事件顺序问题

Spring 提供了一个SmartApplicationListener类，可以支持listener之间的触发顺序，普通的ApplicationListener优先级最低（最后触发）。可以对同一个事件多个监听需顺序执行下使用。

  1. @Component
  2. public class MyListener implements SmartApplicationListener {
  3.     private volatile AtomicBoolean isInit = new AtomicBoolean(false);
  4.     @Override
  5.     public boolean supportsEventType(Class<? extends ApplicationEvent> eventType) {
  6.         return eventType == ContextRefreshedEvent.class;
  7.     }
  9.     @Override
  10.     public boolean supportsSourceType(Class<?> sourceType) {
  11.         return sourceType == String.class;//或者直接return true;看需求有没有该限制要求。一般上边那个方法限制事件类型就满足了。
  12.     }
  14.     @Override
  15.     public void onApplicationEvent(ApplicationEvent event) {
  16.         System.out.println("孙悟空在沙僧之后收到新的内容：" + event.getSource());
  17.     }
  20.     //值越小，就先触发
  21.     @Override
  22.     public int getOrder() {
  23.         return 2;
  24.     }
  25. }
  1. supportsEventType：用于指定支持的事件类型，只有支持的才调用onApplicationEvent；
  2. supportsSourceType：支持的目标类型，只有支持的才调用onApplicationEvent；
  3. getOrder：即顺序，越小优先级越高

SmartApplicationListener的源码：

  1. public interface SmartApplicationListener extends ApplicationListener<ApplicationEvent>, Ordered {
  3.     /**
  4.      * Determine whether this listener actually supports the given event type.
  5.      * @param eventType the event type (never {@code null})
  6.      */
  7.     boolean supportsEventType(Class<? extends ApplicationEvent> eventType);
  9.     /**
  10.      * Determine whether this listener actually supports the given source type.
  11.      * <p>The default implementation always returns {@code true}.
  12.      * @param sourceType the source type, or {@code null} if no source
  13.      */
  14.     default boolean supportsSourceType(@Nullable Class<?> sourceType) {
  15.         return true;//默认true。
  16.     }
  18.     /**
  19.      * Determine this listener's order in a set of listeners for the same event.
  20.      * <p>The default implementation returns {@link #LOWEST_PRECEDENCE}.
  21.      */
  22.     @Override
  23.     default int getOrder() {
  24.         return LOWEST_PRECEDENCE;//默认排序值最大，优先级最低。取自Ordered接口。
  25.     }
  27. }
  29. public interface Ordered {
  30.     int HIGHEST_PRECEDENCE = -2147483648;
  31.     int LOWEST_PRECEDENCE = 2147483647;
  33.     int getOrder();
  34. }

发表评论

表情：
评论列表 （有 0 条评论，179人围观）

还没有评论，来说两句吧...

相关阅读