Spring - 事件驱动模型

Spring - 事件驱动模型

  Spring 事件驱动模型也是观察者模式很经典的应用。

  一、Spring 中观察者模式的四个角色

  1.  事件 - ApplicationEvent

  ApplicationEvent 是所有事件对象的父类。ApplicationEvent 继承自 jdk 的 EventObject, 所有的事件都需要继承 ApplicationEvent, 并且通过 source 得到事件源。

  Spring 也为我们提供了很多内置事件，ContextRefreshedEvent、ContextStartedEvent、ContextStoppedEvent、ContextClosedEvent。如下图：

   2. 事件监听 - ApplicationListener

   ApplicationListener，也就是观察者，继承自 jdk 的 EventListener，该类中只有一个方法 onApplicationEvent。当监听的事件发生后该方法会被执行。如下图：

   3. 事件源 - ApplicationContext

   ApplicationContext 是 Spring 中的核心容器，在事件监听中 ApplicationContext 可以作为事件的发布者，也就是事件源。因为 ApplicationContext 继承自 ApplicationEventPublisher。如下图：

 

    在 ApplicationEventPublisher 中定义了事件发布的方法：publishEvent(Object event) 

@FunctionalInterface
public interface ApplicationEventPublisher {

    default void publishEvent(ApplicationEvent event) {
        publishEvent((Object) event);
    }

    void publishEvent(Object event);

}

   4. 事件管理 - ApplicationEventMulticaster

   用于事件监听器的注册和事件的广播。监听器的注册就是通过它来实现的，它的作用是把 ApplicationContext 发布的 Event 广播给它的监听器列表。如下图：

 

     定义事件：

public class MyEvent extends ApplicationEvent {
    public MyEvent(Object source) {
        super(source);
        System.out.println("my Event");
    }
}

    实现事件监听器：

@Component
class MyListenerA implements ApplicationListener<MyEvent> {
    public void onApplicationEvent(MyEvent AyEvent) {
        System.out.println("ListenerA received");
    }
}

@Component
class MyListenerB implements ApplicationListener<MyEvent> {
    public void onApplicationEvent(MyEvent AyEvent) {
        System.out.println("ListenerB received");
    }
}

   除了上面这种方式，还可以使用注解的方式来自定义事件监听器，比如：

// 自定义事件监听器
@Component
class CustomEventListener {
    @EventListener
    public void handleCustomStartupEvent(CustomStartupEvent event) {
        System.out.println("Custom startup event received from: " + event.getSource());
    }
}

   说明：使用@EventListener时，不需要实现onApplicationEvent方法。Spring 会通过反射调用这个方法来处理事件。这种方式使得代码更加简洁，易于阅读。

   事件发布者：

@Component
public class MyPublisher implements ApplicationContextAware {
    private ApplicationContext applicationContext;

    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    public void publishEvent(ApplicationEvent event){
        System.out.println("publish event");
        applicationContext.publishEvent(event);
    }
}

    测试，先用注解方式将 MyPublisher 注入 Spring

@Configuration
@ComponentScan
public class AppConfig {

    @Bean(name = "myPublisher")
    public MyPublisher myPublisher(){
        return new MyPublisher();
    }
}

   客户端测试代码：

public class Client {

    @Test
    public void main() {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        MyPublisher myPublisher = (MyPublisher) context.getBean("myPublisher");
        myPublisher.publishEvent(new MyEvent(this));
    }
}


//运行结果
my Event
publish event
ListenerA received
ListenerB received

  二、显示遍历观察者的问题

  在 Spring 的事件监听机制中，事件的发布和监听机制通常并不直接涉及到在主题对象中显式地遍历观察者（或监听器）。相反，它们利用了 Spring 的应用上下文（ApplicationContext）和事件发布机制来管理事件的发送和监听。

  1. SimpleApplicationEventMulticaster

  Spring 使用 SimpleApplicationEventMulticaster 作为事件广播器，它会负责将事件分发给所有注册的监听器

  SimpleApplicationEventMulticaster 部分代码如下：

public class SimpleApplicationEventMulticaster extends AbstractApplicationEventMulticaster {

   //...

    @Override
    public void multicastEvent(ApplicationEvent event) {
        multicastEvent(event, resolveDefaultEventType(event));
    }

    @Override
    public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
        ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
        Executor executor = getTaskExecutor();
        for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {
            if (executor != null) {
                executor.execute(() -> invokeListener(listener, event));
            }
            else {
                invokeListener(listener, event);
            }
        }
    }
}

   从invokeListener方法追踪到后面的代码，我们看到最终执行的是listener.onApplicationEvent(event);

   其实也就是执行ApplicationListener实现类的onApplicationEvent方法，里面的内容是监听器在事件发生时执行的特定逻辑。

   在 Spring中，事件监听机制通过  ApplicationEventPublisher 和 ApplicationListener 实现了事件的发布和监听。

   事件的分发由 Spring 内部的事件广播器（如 SimpleApplicationEventMulticaster）处理，避免了在主题对象中显式地遍历观察者。

   这种机制的好处包括：

•    解耦：事件发布者和事件监听器之间解耦，提高了系统的灵活性和可维护性。
•    集中管理：事件的注册和分发由 Spring 容器管理，简化了事件处理逻辑。
•    扩展性：可以方便地添加或移除监听器，而不需要修改事件发布的代码。