定义一个事件

就是一个普通的类，继承 ApplicationEvent 即可。

  1. public class LightEvent extends ApplicationEvent {
  2.     private static final long serialVersionUID = 1L;
  3.     private LightColorEnum lightColor;
  4.     public LightEvent(Object source) {
  5.         super(source);
  6.     }
  7.     public LightEvent(Object source, LightColorEnum lightColor) {
  8.         super(source);
  9.         this.setLightColor(lightColor);
  10.     }
  11.     public LightColorEnum getLightColor() {
  12.         return lightColor;
  13.     }
  14.     public void setLightColor(LightColorEnum lightColor) {
  15.         this.lightColor = lightColor;
  16.     }
  18.     public enum LightColorEnum {
  19.         RED("stop"), YELLOW("wait"), GREEN("go");
  21.         private String message;
  23.         private LightColorEnum(String message){
  24.             this.message = message;
  25.         }
  27.         public String getMessage() {
  28.             return message;
  29.         }
  31.         public void setMessage(String message) {
  32.             this.message = message;
  33.         }
  34.     }
  35. }

监听一个事件

  1. @Component
  2. public class LightEventAnnotationListener {
  3.     private static final Logger log = LoggerFactory.getLogger(LightEventAnnotationListener.class);
  5.     @EventListener
  6.     @Async  //异步方法
  7.     public void handler(LightEvent event){
  8.         try {
  9.             Thread.sleep(2000); //模拟一个比较耗时的操作
  10.         } catch (Exception e) {
  11.             e.printStackTrace();
  12.         }
  13.         log.info("traffic light：" + event.getLightColor().getMessage());
  14.         log.info(Thread.currentThread().getName());
  15.     }
  16. }

发布一个事件

  1.     @Autowired
  2.     private ApplicationEventPublisher applicationEventPublisher;
  4.     @RequestMapping("/publish")
  5.     public Object publish(){
  6.         LightEvent lightEvent = new LightEvent(this, LightEvent.LightColorEnum.YELLOW);
  7.         applicationEventPublisher.publishEvent(lightEvent);
  8.         log.info("things after publish");
  9.         return "ok";
  10.     }

异步执行

默认是同步，发布事件后，主线程会等待所有监听方法执行完毕，才会继续下一步，例如
image.png

开启异步

1、启动类

image.png
2、监听方法
image.png

监听器执行顺序


通过 SmartApplicationListener 设置优先级等，可以进行更详细的控制。

  1. import org.springframework.context.ApplicationEvent;
  2. import org.springframework.context.event.SmartApplicationListener;
  3. import org.springframework.stereotype.Component;
  5. /**
  6. * 监听器
  7. * SmartApplicationListener可以设置顺序等
  8. */
  9. @Component
  10. public class WechatListener implements SmartApplicationListener {
  12.     //设置监听优先级，越小越靠前
  13.     @Override
  14.     public int getOrder() {
  15.         return 1;
  16.     }
  18.     //监听器智能所在之一，能够根据事件类型动态监听
  19.     @Override
  20.     public boolean supportsEventType(Class<? extends ApplicationEvent> aClass) {
  21.         return aClass == OrderCreateEvent.class;
  22.     }
  24.     //监听器智能所在之二，能够根据事件发布者类型动态监听
  25.     @Override
  26.     public boolean supportsSourceType(Class<?> aClass) {
  27.         return aClass == OrderServiceImpl.class;
  28.     }
  30.     @Override
  31.     @Async
  32.     public void onApplicationEvent(ApplicationEvent applicationEvent) {
  33.         OrderCreateEvent event = (OrderCreateEvent) applicationEvent;
  34.         //发送微信
  35.         System.out.println(event.getContentList().get(0) + ",您的订单:" + event.getContentList().get(1) + "创建成功! ----by wechat");
  37.     }
  38. }