spring 的 ApplicationListener 事件监听使用了观察者设计模式;

观察者设计模式需要以下几个角色：

  1. 事件
  2. 观察者
  3. 事件发布者

定义事件

  1. // 实现 ApplicationEvent 接口, 定义事件
  2. public class ConnectEventVO extends ApplicationEvent {
  4.     @Getter
  5.     private EventVO eventVO;
  7.     /**
  8.      * Create a new ApplicationEvent.
  9.      *
  10.      * @param source the object on which the event
  11.      *  
  12.      initially occurred (never {@code null})
  13.      */
  14.     public ConnectEventVO(Object source, EventVO eventVO) {
  15.         super(source);
  16.         this.eventVO = eventVO;
  17.     }
  18. }

事件发布

  1.  @Resource
  2.  private ApplicationEventPublisher eventPublisher;
  4.  public void onWebsocketClose(NettyClient ws, int code, Integer tryNum) {
  5.      log.error("@DeribitMarketListener Channel Close!!!.code:{},tryNum:{}", 
  6.                code, tryNum);
  8.      final EventVO eventVO = new EventVO(EXCHANGE_DERIBIT.getExchangeName(),
  9.                                          CLOSE.toString(), this);
  11.      eventPublisher.publishEvent(new ConnectEventVO(this, eventVO));
  12.  }

定义观察者

  1. @Component("connectEventListener")
  2. public class ConnectEventListener {
  4.     @Resource
  5.     private ConnectMonitor connectMonitor;
  7.     /**
  8.      * 处理连接 close 事件
  9.      *
  10.      * @param connectEventVO 事件
  11.      */
  12.     @EventListener(condition = "#connectEventVO.eventVO.connectStatus == 'OPEN'")
  13.     public void handleOpenEvent(ConnectEventVO connectEventVO) {
  14.         log.info("@ConnectEventListener.handleOpenEvent eventVO:{}", 
  15.                  connectEventVO.getEventVO());
  17.         connectMonitor.resetConnectCount(connectEventVO.getEventVO());
  18.     }
  20.     /**
  21.      * 处理连接 open 事件
  22.      *
  23.      * @param connectEventVO 事件
  24.      */
  25.     @EventListener(condition = "#connectEventVO.eventVO.connectStatus == 'CLOSE'")
  26.     public void handleCloseEvent(ConnectEventVO connectEventVO) {
  27.         EventVO eventVO = connectEventVO.getEventVO();
  28.         log.info("@ConnectEventListener.handleCloseEvent exchange:{}", 
  29.                  eventVO.getExchange());
  31.         connectMonitor.reconnect(eventVO);
  32.     }
  33. }

源码相关

事件发布后，拿到所有事件监听者，匹配到后。回调监听者，如果有 async 注解，回调方法会异步执行；

  1. // @see SimpleApplicationEventMulticaster    
  2. public void multicastEvent(final ApplicationEvent event, 
  3.                            @Nullable ResolvableType eventType) {
  4.     ResolvableType type = (eventType != null ? eventType : 
  5.                            resolveDefaultEventType(event));
  6.     for (final ApplicationListener<?> listener : 
  7.          getApplicationListeners(event, type)) {
  9.         Executor executor = getTaskExecutor();
  10.         if (executor != null) {
  11.             executor.execute(() -> invokeListener(listener, event));
  12.         }
  13.         else {
  14.             invokeListener(listener, event);
  15.         }
  16.     }
  17. }

其他

  1. @Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})
  2. @Retention(RetentionPolicy.RUNTIME)
  3. @Documented
  4. public @interface EventListener {
  6.     /**
  7.      * Alias for {@link #classes}.
  8.      */
  9.     @AliasFor("classes")
  10.     Class<?>[] value() default {};
  12.     /**
  13.      * The event classes that this listener handles.
  14.      * <p>If this attribute is specified with a single value, the
  15.      * annotated method may optionally accept a single parameter.
  16.      * However, if this attribute is specified with multiple values,
  17.      * the annotated method must <em>not</em> declare any parameters.
  18.      */
  19.     @AliasFor("value")
  20.     Class<?>[] classes() default {};
  22.     /**
  23.      * Spring Expression Language (SpEL) attribute used for making the
  24.      * event handling conditional.
  25.      * <p>Default is {@code ""}, meaning the event is always handled.
  26.      * <p>The SpEL expression evaluates against a dedicated context that
  27.      * provides the following meta-data:
  28.      * <ul>
  29.      * <li>{@code #root.event}, {@code #root.args} for
  30.      * references to the {@link ApplicationEvent} and method arguments
  31.      * respectively.</li>
  32.      * <li>Method arguments can be accessed by index. For instance the
  33.      * first argument can be accessed via {@code #root.args[0]}, {@code #p0}
  34.      * or {@code #a0}. Arguments can also be accessed by name if that
  35.      * information is available.</li>
  36.      * </ul>
  37.      */
  38.     String condition() default "";
  40. }

@EventListener 的 condition 是支持 SpEL 表达式的，这就会很灵活。

  1. @Component
  2. public class FooPredicate implements Predicate<FooEvent> {
  3.    public boolean test(FooEvent event) {...}
  4. }
  6. // 可以调用 spring bean 的某个方法,作为前置条件
  7. @EventListener(condition="@fooPredicate.test(#event)")
  8. public void handle(FooEvent event) {
  9.     System.out.println();
  10. }

TransactionalEventListener

使用这个listener 可以在事务提交后，做一些定制化的逻辑