没错，这就是 SpringBoot Event的工作原理！

发表于 分类于 阅读次数： 本文字数： 4.1k 阅读时长 ≈ 4 分钟

你好，我是猿java。

这篇文章，我们来详细探讨 Spring Boot 的事件机制的原理、核心源码分析，以及如何在实际开发中使用事件机制。

1. 事件机制是什么？

事件机制是一种设计模式，通过发布/订阅模式来实现组件之间的解耦。在 Spring 中，事件机制主要通过 ApplicationEvent 和 ApplicationListener 来实现，而 Spring Boot 继承了这一机制，提供了更加简化的使用方式。

1.1 主要组成部分

  • 事件（Event）：表示一个具体的事件，通常是继承自 ApplicationEvent。
  • 事件监听器（Listener）：实现了 ApplicationListener 接口的类，用于处理特定的事件。
  • 事件发布者（Publisher）：负责发布事件的组件，通常是 Spring 容器本身。

2. 核心类与结构

在 Spring 和 Spring Boot 中，事件机制的核心类包括：

  1. ApplicationEvent：所有事件的基类。
  2. ApplicationListener：事件监听器的接口。
  3. ApplicationEventPublisher：事件发布的接口。
  4. SimpleApplicationEventMulticaster：事件多播器，用于发布事件给多个监听器。

2.1 ApplicationEvent

1
2
3
4
5
6
7
8
9
10
11
12
public abstract class ApplicationEvent extends EventObject {
    private final long timestamp;

    public ApplicationEvent(Object source) {
        super(source);
        this.timestamp = System.currentTimeMillis();
    }

    public long getTimestamp() {
        return timestamp;
    }
}

所有的事件都需要继承自 ApplicationEvent，它的构造函数中需要传入事件源（即事件的发生者）。

2.2 ApplicationListener

1
2
3
public interface ApplicationListener<T extends ApplicationEvent> {
    void onApplicationEvent(T event);
}

该接口允许用户定义自己的事件处理逻辑。

2.3 ApplicationEventPublisher

1
2
3
public interface ApplicationEventPublisher {
    void publishEvent(ApplicationEvent event);
}

该接口用于发布事件，每个 Spring 容器都是一个事件发布者。

2.4 SimpleApplicationEventMulticaster

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class SimpleApplicationEventMulticaster implements ApplicationEventMulticaster {
    private final List<ApplicationListener<?>> listeners = new ArrayList<>();

    @Override
    public void addApplicationListener(ApplicationListener<?> listener) {
        listeners.add(listener);
    }

    @Override
    public void multicastEvent(ApplicationEvent event) {
        for (ApplicationListener<?> listener : listeners) {
            listener.onApplicationEvent(event);
        }
    }
}

SimpleApplicationEventMulticaster 是 Spring 默认的事件多播器，通过维护一个监听器的列表来完成事件的发布。

3. 事件的发布与处理过程

事件的处理过程通常分为以下几个步骤：

  1. 创建事件：开发者定义具体的事件类，继承自 ApplicationEvent。
  2. 创建监听器：实现 ApplicationListener 接口，处理具体事件。
  3. 注册监听器：在 Spring 上下文中注册监听器。
  4. 发布事件：在需要的地方发布事件。

3.1 自定义事件

1
2
3
4
5
6
7
8
9
10
11
12
public class MyEvent extends ApplicationEvent {
    private String message;

    public MyEvent(Object source, String message) {
        super(source);
        this.message = message;
    }

    public String getMessage() {
        return message;
    }
}

3.2 自定义监听器

1
2
3
4
5
6
7
@Component
public class MyEventListener implements ApplicationListener<MyEvent> {
    @Override
    public void onApplicationEvent(MyEvent event) {
        System.out.println("Received event: " + event.getMessage());
    }
}

3.3 发布事件

1
2
3
4
5
6
7
8
9
10
@Component
public class MyEventPublisher {
    @Autowired
    private ApplicationEventPublisher applicationEventPublisher;

    public void publish(String message) {
        MyEvent event = new MyEvent(this, message);
        applicationEventPublisher.publishEvent(event);
    }
}

3.4 事件的注册与监听

在 Spring Boot 中，组件可以通过 @Component 注解自动注册到 Spring 容器中，Spring 会在启动时自动扫描到 @EventListener 注解的方法并注册。

1
2
3
4
5
6
7
@Component
public class MyEventListener {
    @EventListener
    public void handleEvent(MyEvent event) {
        System.out.println("Handled event: " + event.getMessage());
    }
}

4. Spring Boot事件机制的优势

  1. 解耦合：通过事件机制，组件之间可以相互独立，不需要直接引用。
  2. 扩展性：可以方便地添加新的事件和监听器，实现功能扩展。
  3. 异步处理：可以结合异步机制，处理耗时的事件而不阻塞主线程。

5. 源码分析

为了深入理解事件机制的实现，我们需要查看具体的源码。以下是核心功能的分析：

5.1 事件的发布流程

在 ApplicationContext 中，可以找到事件发布的实现：

1
2
3
4
5
6
7
public void publishEvent(ApplicationEvent event) {
    if (event == null) {
        throw new IllegalArgumentException("Event must not be null");
    }
    // 推送到 ApplicationEventMulticaster
    getApplicationEventMulticaster().multicastEvent(event);
}

这种设计中，ApplicationContext 通过 ApplicationEventMulticaster 将事件发布给所有感兴趣的监听器。

5.2 多播器的处理

在 SimpleApplicationEventMulticaster 中，事件的多播逻辑如下：

1
2
3
4
5
6
@Override
public void multicastEvent(ApplicationEvent event) {
    for (ApplicationListener<?> listener : getApplicationListeners(event)) {
        listener.onApplicationEvent(event);
    }
}

此方法会遍历所有注册的监听器，并调用它们的 onApplicationEvent 方法处理事件。

5.3 监听器的排序

Spring 中允许对监听器进行排序，以控制事件处理的顺序。具体实现是通过 @Order 注解或 Ordered 接口来完成的。

6.使用场景

  1. 用户登录事件：当用户登录时，可以发布一个登录事件，监听器对此进行处理，比如记录日志等。
  2. 订单创建事件：在电商系统中，可以在订单创建时发布事件，处理库存扣减、消息通知等逻辑。
  3. 数据变更事件：在数据更新时，可以广播一个事件，通知其他服务更新缓存或重新加载数据。

7. 总结

本文我们详细地介绍了SpringBoot事件机制的原理、核心源码以及实际使用方法。通过运用事件机制，我们可以更好地实现解耦合和异步处理，为项目的可维护性和扩展性提供支持。

8. 参考文献

9. 学习交流

如果你觉得文章有帮助，请帮忙转发给更多的好友，或关注公众号：猿java，持续输出硬核文章。

drawing