首页 > 软件编程 > Java > 使用Spring的ApplicationEvent实现本地事件驱动的实现方法

使用Spring的ApplicationEvent实现本地事件驱动的实现方法

福牛 4月 26, 2023 26 0

一、介绍

Spring内置了简便的事件机制，可以非常方便的实现事件驱动，核心类包括

  • ApplicationEvent，具体事件内容，事件抽象基类，可继承该类自定义具体事件
  • ApplicationEventPublisher，事件发布器，可以发布ApplicationEvent，也可以发布普通的Object对象
  • ApplicationListener，事件监听器，可以使用注解@EventListener
  • TransactionalEventListener，事务事件监听，可监听事务提交前、提交后、事务回滚、事务完成（成功或失败）

二、使用示例

不定义事件，直接发布Object对象，同步

1、定义发送事件对象

  1. public class UserEntity {
  2.      private long id;
  3.      private String name;
  4.      private String msg;
  5. }

2、定义事件监听器

可以添加条件condition，限制监听具体的事件

  1. @Slf4j
  2. @Component
  3. public class RegisterListener {
  4.      @EventListener(condition = “#entity.id != null and #entity.async==false “)
  5.      public void handlerEvent(UserEntity entity) {
  6.          try {
  7.              // 休眠5秒
  8.              TimeUnit.SECONDS.sleep(5);
  9.          } catch (InterruptedException e) {
  10.              e.printStackTrace();
  11.          }
  12.          log.info(“handlerEvent: {}”, entity);
  13.      }
  14. }

3、定义发送接口以及实现类

  1. public interface IRegisterService {
  2.      public void register(String name);
  3. }
  1. @Service
  2. public class RegisterServiceImpl implements IRegisterService {
  3.      @Resource
  4.      private ApplicationEventPublisher applicationEventPublisher;
  5.      @Override
  6.      public void register(String name) {
  7.          UserEntity entity = new UserEntity();
  8.          entity.setName(name);
  9.          entity.setId(1L);
  10.          entity.setMsg(“新用户注册同步调用”);
  11.          applicationEventPublisher.publishEvent(entity);
  12.      }
  13. }

4、测试Controller类，进行测试

  1. @Slf4j
  2. @Controller
  3. public class TestController {
  4.      @Resource
  5.      private IRegisterService registerService;
  6.      @RequestMapping(“test”)
  7.      @ResponseBody
  8.      public void test1(String name) {
  9.          registerService.register(name);
  10.          log.info(“执行同步调用结束”);
  11.      }
  12. }

在浏览器中输入地址：http://localhost/test?name=nik

控制台输出：

handlerEvent: UserEntity(id=1, name=nik, msg=新用户注册同步调用)
执行同步调用结束

三、异步发布示例

1、在启动类添加异步注解 @EnableAsync

2、在监听方法上添加注解 @Async

  1. @Async
  2. @EventListener(condition = “#entity.name != null and #entity.async “)
  3. public void handlerEventAsync(UserEntity entity) {
  4.      try {
  5.          TimeUnit.SECONDS.sleep(5);
  6.      } catch (InterruptedException e) {
  7.          e.printStackTrace();
  8.      }
  9.      log.info(“handlerEventAsync: {}”, entity);
  10. }

3、在service中添加异步发送方法

  1. @Override
  2. public void registerAsyn(String name) {
  3.      UserEntity entity = new UserEntity();
  4.      entity.setName(name);
  5.      entity.setId(1L);
  6.      entity.setMsg(“新用户注册异步调用”);
  7.      entity.setAsync(true);
  8.      applicationEventPublisher.publishEvent(entity);
  9. }

4、测试

  1. @RequestMapping(“test”)
  2. @ResponseBody
  3. public void test(String name) {
  4.      registerService.registerAsyn(name);
  5.      log.info(“执行异步调用结束”);
  6. }

控制台输出：

执行异步调用结束
handlerEventAsync: UserEntity(id=1, name=nik, msg=新用户注册异步调用)

四、在事务提交后发布事件示例

比如，用户注册成功后给用户发送成功短信，那么注册成功必然是注册方法事务提交成功后才代表成功。

Spring提供了注解@TransactionalEventListener监听事务事件，在@EventListener基础上增加了属性phase，包含以下四个值：

  • AFTER_COMMIT，事务提交成功后，默认
  • BEFORE_COMMIT，事务提交前
  • AFTER_ROLLBACK，事务回滚后
  • AFTER_COMPLETION，事务完成，AFTER_COMMIT 或 AFTER_ROLLBACK

1、自定义事务处理事件

  1. public class RegisterCommitEvent extends ApplicationEvent {
  2.      @Getter
  3.      @Setter
  4.      private String msg;
  5.      @Getter
  6.      @Setter
  7.      private String name;
  8.      public RegisterCommitEvent(UserEntity source) {
  9.          super(source);
  10.          this.msg = source.getMsg();
  11.          this.name = source.getName();
  12.      }
  13. }

2、在处理方法上添加事务注解，@Transactional

  1. @Override
  2. @Transactional
  3. public void registerCommit(String name) {
  4.      UserEntity entity = new UserEntity();
  5.      entity.setName(name);
  6.      entity.setMsg(“新用户注册事务提交事件”);
  7.      RegisterCommitEvent registerEvent = new RegisterCommitEvent(entity);
  8.      userDao.save(entity);
  9.      // 发送事件
  10.      applicationEventPublisher.publishEvent(registerEvent);
  11. }

3、添加事务事件监听

  1. @Async
  2. @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
  3. public void handlerEventCmmit(RegisterCommitEvent event) {
  4.      try {
  5.          TimeUnit.SECONDS.sleep(5);
  6.      } catch (InterruptedException e) {
  7.          e.printStackTrace();
  8.      }
  9.      log.info(“handlerEventCmmit: {}”, event);
  10. }

4、测试

  1. @RequestMapping(“test”)
  2. @ResponseBody
  3. public void test(String name) {
  4.      registerService.registerCommit(name);
  5.      log.info(“执行事务调用结束”);
  6. }

控制台输出：

执行事务调用结束
handlerEventCmmit: RegisterCommitEvent[source=UserEntity(id=0, name=nik, msg=新用户注册事务提交事件)]

总结

Spring ApplicationEvent事件处理机制使用起来简单方便，可以对程序进行有效解耦。

虽然可以发送任意类型的对象，但是在实际业务中容易产生混乱，建议根据实际业务，定义好各类事件，并在监听方法中实现异步处理。

到此这篇关于使用Spring的ApplicationEvent实现本地事件驱动的实现方法的文章就介绍到这了,更多相关Spring ApplicationEvent本地事件驱动内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

标签

相关推荐

发表评论