Spring Event观察者模式事件监听详解

什么是Spring Event

Spring Event是Spring Framework中实现的一种事件通知机制。在Spring应用中，当某个事件发生时，Spring可以通知感兴趣的监听器执行相应的处理逻辑。这也被称为观察者模式。

Spring Event的使用步骤

创建事件

首先，需要定义一个事件类，例如：

public class MyEvent {
    private String message;

    public MyEvent(String message) {
        this.message = message;
    }

    public String getMessage() {
        return message;
    }
}

注意，这个事件类必须继承ApplicationEvent类。

发布事件

当某个事件发生时，需要发布该事件：

@Autowired
private ApplicationEventPublisher publisher;

public void sendMessage(String message) {
    publisher.publishEvent(new MyEvent(message));
}

监听事件

我们还需要定义一个监听事件的处理器：

@Component
public class MyEventHandler implements ApplicationListener<MyEvent> {
    @Override
    public void onApplicationEvent(MyEvent event) {
        System.out.println("Received message: " + event.getMessage());
    }
}

实现ApplicationListener接口，并指定要监听的事件类型。

执行结果

最后，当sendMessage()方法被调用时，MyEventHandler就会收到通知，并执行相应的处理逻辑。

@Test
public void testSendMessage() {
    myService.sendMessage("hello world");
}

在执行测试方法时，控制台会输出:

Received message: hello world

使用Spring Event的好处

使用Spring Event可以让大家更加聚焦在业务代码上，而不是过于关注事件的注册和管理，从而增加了代码的可读性和维护性。而且，事件机制可以更好地解耦各个功能模块，使系统更加稳定和灵活。

Spring Event示例

下面再来看一个实际应用的示例。

假设我们有一个订单服务，需要在订单状态发生变化时通知其他相关服务。

首先，我们定义一个订单状态变更事件：

public class OrderStatusChangedEvent extends ApplicationEvent {

    private final Order order;
    private final OrderStatus from;
    private final OrderStatus to;

    public OrderStatusChangedEvent(Order order, OrderStatus from, OrderStatus to) {
        super(order);
        this.order = order;
        this.from = from;
        this.to = to;
    }

    public Order getOrder() {
        return order;
    }

    public OrderStatus getFrom() {
        return from;
    }

    public OrderStatus getTo() {
        return to;
    }
}

然后，在订单状态发生变化时发布该事件：

@Service
public class OrderService {

    private final ApplicationEventPublisher publisher;

    @Autowired
    public OrderService(ApplicationEventPublisher publisher) {
        this.publisher = publisher;
    }

    public void updateOrderStatus(Order order, OrderStatus status) {
        OrderStatus from = order.getStatus();
        order.setStatus(status);
        publisher.publishEvent(new OrderStatusChangedEvent(order, from, status));
    }
}

最后，我们可以定义一个监听器，负责处理该事件：

@Component
public class OrderEventListener {

    @Autowired
    private AnotherService anotherService;

    @Autowired
    private YetAnotherService yetAnotherService;

    @EventListener
    public void handleOrderStatusChanged(OrderStatusChangedEvent event) {
        Order order = event.getOrder();
        OrderStatus from = event.getFrom();
        OrderStatus to = event.getTo();
        // Do something with order, from, and to.
        anotherService.doSomething(order, from, to);
        yetAnotherService.doSomethingElse(order, from, to);
    }
}

这个监听器使用了@EventListener注解来标志它可以处理OrderStatusChangedEvent事件。在事件发生时，handleOrderStatusChanged()方法将会被调用，并执行一些处理逻辑。

上面这个示例演示了如何在Spring应用中实现事件机制。在实际应用中，我们可以根据业务需要定义不同的事件和监听器，来支持各种场景下的事件通知。