SpringBoot的监听器

springBoot的监听器

背景

在开发工作中，会遇到一种场景，做完某一件事情以后，需要广播一些消息或者通知，告诉其他的模块进行一些事件处理，一般来说，可以一个一个发送请求去通知，但是有一种更好的方式，那就是事件监听，事件监听也是设计模式中 发布-订阅模式、观察者模式的一种实现。

**观察者模式：**简单的来讲就是你在做事情的时候身边有人在盯着你，当你做的某一件事情是旁边观察的人感兴趣的事情的时候，他会根据这个事情做一些其他的事，但是盯着你看的人必须要到你这里来登记，否则你无法通知到他（或者说他没有资格来盯着你做事情）。

对于 Spring 容器的一些事件，可以监听并且触发相应的方法。通常的方法有 2 种，

1. ApplicationListener 接口
2. @EventListener 注解

简介

要想顺利的创建监听器，并起作用，这个过程中需要这样几个角色：
1、事件（event）可以封装和传递监听器中要处理的参数，如对象或字符串，并作为监听器中监听的目标。
2、监听器（listener）具体根据事件发生的业务处理模块，这里可以接收处理事件中封装的对象或字符串。
3、事件发布者（publisher）事件发生的触发者。

ApplicationListener接口的实现形式

ApplicationListener接口的讲解

ApplicationListener 接口的定义如下：

public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {
 
/**
* Handle an application event.
* @param event the event to respond to
*/
void onApplicationEvent(E event);
}

它是一个泛型接口，泛型的类型必须是 ApplicationEvent 及其子类，只要实现了这个接口，那么当容器有相应的事件触发时，就能触发 onApplicationEvent 方法**(自动去执行)**。ApplicationEvent 类的子类有很多.

简单使用1

使用方法很简单，就是实现一个 ApplicationListener 接口，并且将加入到容器中就行。

这里监听的是Applicaton启动时候的事情。

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

然后启动自己的springboot项目：

@SpringBootApplication
//在SpringBootApplication上使用@ServletComponentScan注解后，Servlet、Filter、Listener可以直接通过@WebServlet、@WebFilter、@WebListener注解自动注册，无需其他代码。
@ServletComponentScan
@EnableAsync
@EnableTransactionManagement
public class RejjieApplication {

    public static void main(String[] args) {
        SpringApplication.run(RejjieApplication.class, args);
    }

}

结果

事件触发非注解的方式：org.springframework.boot.web.servlet.context.ServletWebServerInitializedEvent

简单使用2 自定义事件和监听器

定义事件

首先，我们需要定义一个事件（MyTestEvent)，需要继承Spring的ApplicationEvent

public class MyTestEvent extends ApplicationEvent {
    /**
     *
     */
    private static final long serialVersionUID = 1L;

    private String msg ;

    public MyTestEvent(Object source,String msg) {
        super(source);
        this.msg = msg;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }
}

定义监听器

需要定义一下监听器，自己定义的监听器需要实现ApplicationListener，同时泛型参数要加上自己要监听的事件Class名，在重写的方法onApplicationEvent中，添加自己的业务处理：

​ 当监听到具体的时间的时候，会自动调用onApplication方法

@Component
public class MyNoAnnotationListener implements ApplicationListener<MyTestEvent> {

    @Override
    public void onApplicationEvent(MyTestEvent event) {
        System.out.println("非注解监听器：" + event.getMsg());
    }

}

事件发布

有了事件，有了事件监听者，那么什么时候触发这个事件呢？

​ 每次想让监听器收到事件通知的时候，就可以调用一下事件发布的操作。首先在类里自动注入ApplicationEventPublisher，这个也就是我们的ApplicationCOntext，它实现了这个接口。

@Component
public class MyTestEventPubLisher {
    @Autowired
    private ApplicationEventPublisher applicationEventPublisher;

    /**
     *  事件发布方法
     */
    public void pushListener(String msg) {
        applicationEventPublisher.publishEvent(new MyTestEvent(this, msg));
    }

}

测试

用一个http请求来模拟

@RestController
public class TestEventListenerController1 {

    @Autowired
    private MyTestEventPubLisher publisher;

    @RequestMapping(value = "/test/testPublishEvent111" )
    public void testPublishEvent(){
        publisher.pushListener("我来了！");
    }
}

启动项目，可以看到控制台输出，测试完成：

事件触发：com.njit.personal.unannotation.MyTestEvent // 这个是上面那个事件监控的的输出
非注解监听器：我来了！

EventLister的使用

基本概念

用途
将一个方法标记为监听器，用于监听应用程序事件，事件可以是 ApplicationEvent实例，也可以是其他任意的对象。

​ 如果一个监听器（被标注的方法）只支持单一的事件类型，那么该方法可以声明一个唯一的参数用来反映要监听的事件类型。

​ 如果一个监听器（被标注的方法）支持多种事件类型，那么需要使用注解的classes属性指定一个或多个支持的事件类型。

事件处理条件
可以通过 condition 属性指定一个SpEL表达式，如果返回 “true”, “on”, “yes”, or “1” 中的任意一个，则事件会被处理，否则不会。

处理器
对 @EventListener 注解的处理是通过内部的EventListenerMethodProcessor Bean进行的，当使用Java配置时，它被自动注册，当使用XML配置时，则通过context:annotation-config/或context:component-scan/元素手动注册。

返回值
被标注的方法可以没有返回值，也可以有返回值。当有返回值是，其返回值会被当作为一个新的事件发送。如果返回类型是数组或集合，那么数组或集合中的每个元素都作为一个新的单独事件被发送。

异常处理
同步监听器抛出的所有checked异常都会被封装成 UndeclaredThrowableException ，因为事件发布者只能处理运行时异常（unchecked异常）。

异步监听器
当需要异步处理监听器时，可以在监听器方法上再增加另外的一个Spring注解 @Async，但需要注意以下限制：

​ 监听器报错不会传递给事件发起者，因为双方已经不在同一个线程了。
​ 异步监听器的非空返回值不会被当作新的事件发布。如果需要发布新事件，需要注入 ApplicationEventPublisher后手动发布。
监听器排序
如果同一个事件可能会被多个监听器监听处理，那么我们可以使用 @Order 注解对各个监听器进行排序。

使用实例

新建事件类

PersonUpdateEvent

@Component
@Data
@NoArgsConstructor
@AllArgsConstructor
public class PersonUpdateEvent {
    private Integer id;
    private String name;
    private Integer age;

}

PersonSaveEvent

@Component
@Data
@NoArgsConstructor
@AllArgsConstructor
public class PersonSaveEvent {
    private Integer id;
    private String name;
    private Integer age;

}

单一事件监听器

发布事件

@Service
public class EventPublisher {

    private ApplicationEventPublisher  eventPublisher;

    @Autowired
    public void setEventPublisher(ApplicationEventPublisher eventPublisher) {
        this.eventPublisher = eventPublisher;
    }

    public void publishPersonSaveEvent(){
        PersonSaveEvent  saveEvent = new PersonSaveEvent();
        saveEvent.setId(1);
        saveEvent.setName("i余数");
        saveEvent.setAge(18);
        eventPublisher.publishEvent(saveEvent);
    }
}

监听事件

@Slf4j
@Service
public class EventListenerService {

    @EventListener
    public void handleForPersonSaveEvent(PersonSaveEvent saveEvent){
        log.info("saveEvent -> {}", saveEvent);
    }
}

结果

saveEvent -> PersonSaveEvent(id=1, name=i余数, age=18)

使用classes实现多事件监听器

发布事件
在上一个示例的基础上，再多加一个PersonUpdateEvent事件。

public void publishPersonUpdateEvent(){
    PersonUpdateEvent  updateEvent = new PersonUpdateEvent();
    updateEvent.setId(1);
    updateEvent.setName("i余数");
    updateEvent.setAge(19);
    eventPublisher.publishEvent(updateEvent);
}

监听事件

@EventListener(classes = {PersonSaveEvent.class, PersonUpdateEvent.class})
public void handleForPersonSaveAndUpdateEvent(Object event){
    log.info("multi handle event -> {}", event);
}

验证结果

可以监听到多个事件

multi handle event -> PersonSaveEvent(id=1, name=i余数, age=18)
multi handle event -> PersonUpdateEvent(id=1, name=i余数, age=19)

使用condition筛选监听的事件

发布事件

public void publishPersonSaveEvent(){
    PersonSaveEvent  saveEvent = new PersonSaveEvent();
    saveEvent.setId(1);
    saveEvent.setName("i余数");
    saveEvent.setAge(18);
    eventPublisher.publishEvent(saveEvent);

    PersonSaveEvent  saveEvent2 = new PersonSaveEvent();
    saveEvent2.setId(2);
    saveEvent2.setName("i余数");
    saveEvent2.setAge(18);
    eventPublisher.publishEvent(saveEvent2);
}

监听事件

public void publishPersonSaveEvent(){
    PersonSaveEvent  saveEvent = new PersonSaveEvent();
    saveEvent.setId(1);
    saveEvent.setName("i余数");
    saveEvent.setAge(18);
    eventPublisher.publishEvent(saveEvent);

    PersonSaveEvent  saveEvent2 = new PersonSaveEvent();
    saveEvent2.setId(2);
    saveEvent2.setName("i余数");
    saveEvent2.setAge(18);
    eventPublisher.publishEvent(saveEvent2);
}

结果验证
id为2的事件不满足条件，所以不会执行。

只处理id等于1的 -> PersonSaveEvent(id=1, name=i余数, age=18)

有返回值的监听器

返回一个单一对象

发布事件

public void publishPersonSaveEvent(){
    PersonSaveEvent  saveEvent = new PersonSaveEvent();
    saveEvent.setId(1);
    saveEvent.setName("i余数");
    saveEvent.setAge(18);
    eventPublisher.publishEvent(saveEvent);
}

监听事件

@EventListener
public void handleForPersonUpdateEvent(PersonUpdateEvent updateEvent){
    log.info("handle update event -> {}", updateEvent);
}


@EventListener
public PersonUpdateEvent handleHaveReturn(PersonSaveEvent saveEvent){
    log.info("handle save event -> {}", saveEvent);
    PersonUpdateEvent updateEvent = new PersonUpdateEvent();
    updateEvent.setId(saveEvent.getId());
    updateEvent.setName(saveEvent.getName());
    updateEvent.setAge(saveEvent.getAge());
    return updateEvent;
}

验证结果
可以看到我们监听到了2个事件，PersonSaveEvent是我们主动发布的事件，PersonUpdateEvent 是 handleHaveReturn 方法的返回值，会被 Spring 自动当作一个事件被发送。

handle save event -> PersonSaveEvent(id=1, name=i余数, age=18)
handle update event -> PersonUpdateEvent(id=1, name=i余数, age=18)

返回一个集合

将监听器稍作修改，使其返回一个集合。

@EventListener
public List<PersonUpdateEvent> handleHaveReturn(PersonSaveEvent saveEvent){
    log.info("handle save event -> {}", saveEvent);
    List<PersonUpdateEvent> events = new ArrayList<>();
    PersonUpdateEvent updateEvent = new PersonUpdateEvent();
    updateEvent.setId(saveEvent.getId());
    updateEvent.setName(saveEvent.getName());
    updateEvent.setAge(saveEvent.getAge());
    events.add(updateEvent);

    PersonUpdateEvent updateEvent2 = new PersonUpdateEvent();
    BeanUtils.copyProperties(updateEvent, updateEvent2);
    events.add(updateEvent2);
    return events;

}

查看结果可以发现，集合中的每个对象都被当作一个单独的事件进行发送。

handle save event -> PersonSaveEvent(id=1, name=i余数, age=18)
handle update event -> PersonUpdateEvent(id=1, name=i余数, age=18)
handle update event -> PersonUpdateEvent(id=1, name=i余数, age=18)

返回一个数组

和返回值为集合一样，数组中的每个对象都被当作一个单独的事件进行发送。

异步监听器

创建两个监听器，一个同步一个异步，异步监听器就是在方法上加一个 @Async 标签即可（你可以指定线程池）。

同时使用异步监听器时候需要再Application类上加上 @EnableAsync

@SpringBootApplication
//在SpringBootApplication上使用@ServletComponentScan注解后，Servlet、Filter、Listener可以直接通过@WebServlet、@WebFilter、@WebListener注解自动注册，无需其他代码。
@ServletComponentScan
@EnableAsync
@EnableTransactionManagement
public class RejjieApplication {

    public static void main(String[] args) {
        SpringApplication.run(RejjieApplication.class, args);
    }

}

@EventListener
public void handleForPersonSaveEvent(PersonSaveEvent saveEvent){
    log.info("handle event -> {}", saveEvent);
}

@Async
@EventListener
public void handleForPersonSaveEventAsync(PersonSaveEvent saveEvent){
    log.info("async handle event -> {}", saveEvent);
}

从执行结果可以看出，异步线程是 task-1，不是主线程 main，即异步是生效的。

INFO 3851 --- [           main] i.k.s.e.listener.EventListenerService    : handle event -> PersonSaveEvent(id=1, name=i余数, age=18)
INFO 3851 --- [         task-1] i.k.s.e.listener.EventListenerService    : async handle event -> PersonSaveEvent(id=1, name=i余数, age=18)

监听器异常处理

同步异常处理

使用 SimpleApplicationEventMulticaster 处理同步监听器抛出异常。
先定义一个ErrorHandler:

@Slf4j
@Component
public class MyErrorHandler implements ErrorHandler {
    @Override
    public void handleError(Throwable t) {
        log.info("handle error -> {}", t.getClass());
    }
}

将自定义ErrorHandler绑定到 SimpleApplicationEventMulticaster

这里涉及一个@PostConstruce

@Slf4j
@Service
public class EventListenerService {

    @Autowired
    private SimpleApplicationEventMulticaster simpleApplicationEventMulticaster;

    @Autowired
    private MyErrorHandler errorHandler;

    @PostConstruct
    public void init(){
        simpleApplicationEventMulticaster.setErrorHandler(errorHandler);
    }

    @Order(1)
    @EventListener
    public void handleForPersonSaveEvent(PersonSaveEvent saveEvent) throws AuthException {
        log.info("handle event -> {}", saveEvent);
        throw new AuthException("test exception");
    }
}   

结果：可以看到捕获的异常是 UndeclaredThrowableException。

handle event -> PersonSaveEvent(id=1, name=i余数, age=18)
handle error -> class java.lang.reflect.UndeclaredThrowableException

异步异常处理

使用 SimpleAsyncUncaughtExceptionHandler 来处理 @Async 抛出的异常。

@Configuration
public class AsyncConfig implements AsyncConfigurer {
    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return new SimpleAsyncUncaughtExceptionHandler();
    }
}

监听器代码：人为的抛出一个异常。

@Async
@EventListener
public void handleForPersonSaveEvent(PersonSaveEvent saveEvent) throws AuthException {
    log.info("handle event -> {}", saveEvent);
    throw new AuthException("test exception");
}

结果: SimpleAsyncUncaughtExceptionHandler捕获到了 @Async 方法抛出的异常

 INFO 4416 --- [         task-1] i.k.s.e.listener.EventListenerService    : handle event -> PersonSaveEvent(id=1, name=i余数, age=18)
ERROR 4416 --- [         task-1] .a.i.SimpleAsyncUncaughtExceptionHandler : Unexpected exception occurred invoking async method: public void xxxx.handleForPersonSaveEvent(xxxx.PersonSaveEvent) throws javax.security.auth.message.AuthException

监听器排序

如果同时有多个监听器监听同一个事件，默认情况下监听器的执行顺序是随机的，如果想要他们按照某种顺序执行，可以借助Spring的另外一个注解 @Order 实现。

创建三个监听器，并使用@Order 排好序。

@Order(1)
@EventListener
public void handleForPersonSaveEvent(PersonSaveEvent saveEvent){
    log.info("handle event1 -> {}", saveEvent);
}

@Order(2)
@EventListener
public void handleForPersonSaveEvent2(PersonSaveEvent saveEvent){
    log.info("handle event2 -> {}", saveEvent);
}

@Order(3)
@EventListener
public void handleForPersonSaveEvent3(PersonSaveEvent saveEvent){
    log.info("handle event3 -> {}", saveEvent);
}

从执行结果可以看到，确实是按照@Order中指定的顺序执行的。

handle event1 -> PersonSaveEvent(id=1, name=i余数, age=18)
handle event2 -> PersonSaveEvent(id=1, name=i余数, age=18)
handle event3 -> PersonSaveEvent(id=1, name=i余数, age=18)

Spring事件最佳实践

通用泛型类事件

事件类可以不继承ApplicationEvent类，定义通用泛型类事件对象,其他事件对象继承该对象

@Data
@AllArgsConstructor
public class GenericEvent<T>  {
    /**
     * 业务类型
     */
    private String billType;
    private T data;

}

实体类

@Data
public class SendBank {
    private String username;
    private String paymentAccount;
    private String money;

    @Override
    public String toString() {
        return "SendBank{" +
                "username='" + username + '\'' +
                ", paymentAccount='" + paymentAccount + '\'' +
                ", money='" + money + '\'' +
                '}';
    }
}

发送银行成功事件,继承上面的事件

public class SendBankSuccessEvent extends GenericEvent<SendBank>{

    public SendBankSuccessEvent(String billType, SendBank data) {
        super(billType, data);
    }
}

发送银行失败事件

public class SendBankFailEvent extends GenericEvent<SendBank>{
    public SendBankFailEvent(String billType, SendBank data) {
        super(billType, data);
    }
}

发送银行退回事件

public class SendBankGoBackEvent extends GenericEvent<Map>{
    public SendBankGoBackEvent(String billType, Map data) {
        super(billType, data);
    }
}

发布事件类

发送事件类一般可以直接是Service层的实现类

@Service
public class SendBankServiceImpl {

    @Resource
    private ApplicationContext applicationContext;

    public void sendBank(String event, String billType) {
        SendBank sendBank = new SendBank();
        sendBank.setUsername("风雨修");
        sendBank.setPaymentAccount("中国建设银行");
        sendBank.setMoney("2000");
        if ("success".equals(event)) {
            if ("DYZC".equals(billType)) {
                applicationContext.publishEvent(new SendBankSuccessEvent("DYZC", sendBank));
            }
            if ("ZYSL".equals(billType)) {
                applicationContext.publishEvent(new SendBankSuccessEvent("ZYSL", sendBank));
            }
            if ("SLHZ".equals(billType)) {
                applicationContext.publishEvent(new SendBankSuccessEvent("SLHZ", sendBank));
            }
        } else if ("fail".equals(event)){

            applicationContext.publishEvent(new SendBankFailEvent("ZYSL", sendBank));
        } else if ("goBack".equals(event)){
            HashMap<Object, Object> map = Maps.newHashMap();
            map.put("username", "喜羊羊sk");
            map.put("age", 23);
            map.put("sex","男");
            map.put("hobby","hello world");
            applicationContext.publishEvent(new SendBankGoBackEvent("SLHZ", map));
        }
    }
}

事件监听类

@EventListener注解属性

• classes: 此侦听器处理的事件类。

• condition:用于使事件处理成为条件的SpEL表达式,如果表达式的计算结果为布尔值true,则将处理该事件

  一个事件可以有很多个监听者，可以通过classes属性指定具体监听事件类,通过condition可以指定事件类的属性值满足条件才生效执行

  package rejjie.LIstener.Perfect;
  
  import lombok.extern.slf4j.Slf4j;
  import org.springframework.context.event.EventListener;
  import org.springframework.stereotype.Component;
  
  import java.util.Map;
  
  @Component
  @Slf4j
  public class GenericEventListener {
  
      /**
       *  同一种事件,不同业务类型。实现不同的监听处理
       *  通过 @EventListener注解属性
       *    classes: 此侦听器处理的事件类。
       *    condition:用于使事件处理成为条件的SpEL表达式,如果表达式的计算结果为布尔值true,则将处理该事件
       */
      @EventListener(classes = SendBankSuccessEvent.class,condition = "#event.billType.equalsIgnoreCase('dyzc')")
      public void DYZCsendBankSuccessListener(GenericEvent<SendBank> event) {
          log.info("event: {}", event);
          log.info("data: {}", event.getData());
      }
  
      @EventListener(classes = SendBankSuccessEvent.class,condition = "#event.billType.equalsIgnoreCase('zysl')")
      public void ZYSLsendBankSuccessListener(GenericEvent<SendBank> event) {
          log.info("event: {}", event);
          log.info("data: {}", event.getData());
      }
  
      @EventListener(classes = SendBankSuccessEvent.class,condition = "#event.billType.equalsIgnoreCase('slhz')")
      public void SLHZsendBankSuccessListener(GenericEvent<SendBank> event) {
          log.info("event: {}", event);
          log.info("data: {}", event.getData());
      }
      /**
       *  end
       *
       */
  
      @EventListener(classes = SendBankFailEvent.class)
      public void sendBankFailListener(GenericEvent<SendBank> event) {
          log.info("event: {}", event);
          log.info("data: {}", event.getData());
      }
  
      @EventListener(classes = SendBankGoBackEvent.class)
      public void sendGoBackListener(GenericEvent<Map> event) {
          log.info("event: {}", event);
          log.info("data: {}", event.getData());
      }
  }
  
  

  优化: 可以把billType的所有类型做成常量统一维护

  public class BillTypeConstant {
      public static final String DYZC= "dyzc";
      public static final String ZYSL= "zysl";
  }
  
  

  监听事件修改为

  @EventListener(classes = SendBankSuccessEvent.class,condition = "#event.billType=='"+BillTypeConstant.DYZC+"'")
  public void DYZCsendBankSuccessListener(GenericEvent<SendBank> event) {
      log.info("event: {}", event);
      log.info("data: {}", event.getData());
  }
  
  @EventListener(classes = SendBankSuccessEvent.class,condition = "#event.billType=='"+BillTypeConstant.ZYSL+"'")
  public void ZYSLsendBankSuccessListener(GenericEvent<SendBank> event) {
      log.info("event: {}", event);
      log.info("data: {}", event.getData());
  }
  
  

  测试

  @Slf4j
  @RestController
  @RequestMapping("/sendBank")
  public class SendBankController {
  
      @Autowired
      private SendBankService sendBankService;
  
      @PostMapping("/event")
      public void sendBank(){
          sendBankService.sendBank("success","ZYSL");
      }
  }
  
  

事务绑定事件

​ 当一些场景下，比如在用户注册成功后，即数据库事务提交了，之后再异步发送邮件等，不然会发生数据库插入失败，但事件却发布了，也就是邮件发送成功了的情况。此时，我们可以使用@TransactionalEventListener注解或者TransactionSynchronizationManager类来解决此类问题，也就是：事务成功提交后，再执行事件。

TransactionSynchronizationManager类

@EventListener
public void afterRegisterSendMail(SendEmailEvent event) {
    // Spring 4.2 之前
    TransactionSynchronizationManager.registerSynchronization(

            new TransactionSynchronizationAdapter() {
                @Override
                public void afterCommit() {
                    send(username);
                }
            }
    );
}

上面的代码将在事务提交后执行.如果在非事务context中将抛出java.lang.IllegalStateException: Transaction synchronization is not active

@EventListener
public void afterRegisterSendMail(SendEmailEvent event) {
    // Spring 4.2 之前
    if (TransactionSynchronizationManager.isActualTransactionActive()) {
        TransactionSynchronizationManager.registerSynchronization(
                new TransactionSynchronizationAdapter() {
                    @Override
                    public void afterCommit() {
                        send(event);
                    }

                });

    } else {
        send(username);
    }
}

这样无论是否有事务都能兼容啦.

@TransactionalEventListener

Spring 4.2除了EventListener之外,额外提供了新的注解@TransactionalEventListener

@TransactionalEventListener
public void sendEmail(String username) {
    log.info("transactionEventListener start");
    // 发生验证码
    send(username);
    log.info("transactionEventListener finish");
}

这个注解的强大之处在于可一直控制事务的 before/after commit, after rollback ,after completion (commit或 rollback). 默认情况下,在事务中的Event将会被执行,
参考
https://blog.youkuaiyun.com/qq_37687594/article/details/113200974
https://blog.youkuaiyun.com/justyuze/article/details/128569661
https://blog.youkuaiyun.com/qq_45297578/article/details/126844577