springBoot Event实现异步消费机制

springBoot Event实现异步消费机制

ApplicationEvent以及Listener是Spring为我们提供的一个事件监听、订阅的实现，内部实现原理是观察者设计模式，设计初衷也是为了系统业务逻辑之间的解耦，提高可扩展性以及可维护性。

通过 ApplicationEvent 类和 ApplicationListener 接口来提供在 ApplicationContext 中处理事件。如果一个 bean 实现 ApplicationListener，那么每次 ApplicationEvent 被发布到 ApplicationContext 上，那个 bean 会被通知。

(1) ApplicationContext.publishEvent 默认是同步操作, 并非异步操作，发布事件后需要等 @EventListener 执行完

(2) 如果需要开启异步操作 需要在 @EventListener 上 增加 @Async 注解。

创建OrderEvent

用于传递消息

@Data
public class OrderEvent extends ApplicationEvent {  // 第一步 extends ApplicationEvent

   // 可添加多个字段
    public String message;

  	// 根据需要添加字段
    public OrderEvent(Object source, String message) {
        // 固定写法
        super(source);  
        this.message = message;
    }

}

生产者

@RestController
@RequestMapping("order")
public class OrderController {

    // 第一步
    @Autowired
    private ApplicationContext applicationContext;

    @GetMapping("/createOrder/{orderNo}")
    public String createOrder(@PathVariable String orderNo) {
      
      	// 第二步
        applicationContext.publishEvent(new OrderEvent(this, String.format("订单创建成功，订单号为：%s", orderNo)));
        return "订单常见成功";
      
    }
}

监听者

方式一：Event事件监听

事件监听是无序的

@Component   // 第一步
public class GlobalListener {

    private static Logger logger = LoggerFactory.getLogger(GlobalListener.class);

    @EventListener(OrderEvent.class)  // 第二步
    public void createOrder(OrderEvent orderEvent) {
        logger.info("{} 监听器接收到消息，订单号为：{}", LocalDateTime.now(), orderEvent.getMessage());
    }
}

方式二：实现 ApplicationListener接口

事件监听是无序的

@Component		// 第一步
public class OrderListener implements ApplicationListener<OrderEvent> {		// 第一步 implements ApplicationListener<OrderEvent>

    private static Logger logger = LoggerFactory.getLogger(OrderListener.class);

  	// 第三步
    @Override
    public void onApplicationEvent(OrderEvent orderEvent) {
        logger.info("方式二： {} 监听器接收到消息，订单号为：{}", LocalDateTime.now(), orderEvent.getMessage());
    }
}

方式三：SmartApplicationListener实现有序监听

---

事件监听是有序的

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationEvent;
import org.springframework.context.event.SmartApplicationListener;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;

@Component  // 第一步
public class SmartOrderListener implements SmartApplicationListener {

    private static Logger logger = LoggerFactory.getLogger(SmartOrderListener.class);

    /**
     * 该方法返回true&supportsSourceType同样返回true时，才会调用该监听内的onApplicationEvent方法
     *
     * @param aClass 接收到的监听事件类型
     * @return
     */
    @Override
    public boolean supportsEventType(Class<? extends ApplicationEvent> aClass) {
        // 指定只有 OrderEvent 监听类型才会执行下面逻辑
        return aClass == OrderEvent.class;
    }

    /**
     * 该方法返回true&supportsEventType同样返回true时，才会调用该监听内的onApplicationEvent方法
     *
     * @param sourceType
     * @return
     */
    @Override
    public boolean supportsSourceType(Class<?> sourceType) {
        //只有在 OrderService 内发布的 OrderEvent 事件时才会执行下面逻辑，这里没有，下面是案列
        // return aClass == OrderService.class;
        return SmartApplicationListener.super.supportsSourceType(sourceType);
    }

    /**
     * supportsEventType & supportsSourceType 两个方法返回true时调用该方法执行业务逻辑
     *
     * @param applicationEvent 具体监听实例，这里是 OrderEvent
     */
    @Override
    public void onApplicationEvent(ApplicationEvent applicationEvent) {

        //转换事件类型
        OrderEvent orderEvent = (OrderEvent) applicationEvent;
        String message = orderEvent.getMessage();
        logger.info("方式三(有序)： {} 监听器接收到消息，订单号为：{}", LocalDateTime.now(), orderEvent.getMessage());
    }

    @Override
    public int getOrder() {
        return 0;
    }

}