⭐⭐⭐ Spring Boot 项目实战	⭐⭐⭐ Spring Cloud 项目实战
《Dubbo 实现原理与源码解析 —— 精品合集》	《Netty 实现原理与源码解析 —— 精品合集》
《Spring 实现原理与源码解析 —— 精品合集》	《MyBatis 实现原理与源码解析 —— 精品合集》
《Spring MVC 实现原理与源码解析 —— 精品合集》	《数据库实体设计合集》
《Spring Boot 实现原理与源码解析 —— 精品合集》	《Java 面试题 + Java 学习指南》

摘要: 原创出处 juejin.cn/post/7214699255507959869 「佳庆」欢迎转载，保留摘要，谢谢！

🙂🙂🙂关注**微信公众号：【芋道源码】**有福利：

RocketMQ / MyCAT / Sharding-JDBC 所有源码分析文章列表

RocketMQ / MyCAT / Sharding-JDBC 中文注释源码 GitHub 地址

您对于源码的疑问每条留言都将得到认真回复。甚至不知道如何读源码也可以请教噢。

新的源码解析文章实时收到通知。每周更新一篇左右。

认真的源码交流微信群。

前言

本文主要是简单的讲述了Spring的事件机制，基本概念，讲述了事件机制的三要素事件、事件发布、事件监听器。如何实现一个事件机制，应用的场景，搭配@Async注解实现异步的操作等等。希望对大家有所帮助。

Spring的事件机制的基本概念

Spring的事件机制是Spring框架中的一个重要特性，基于观察者模式实现，它可以实现应用程序中的解耦，提高代码的可维护性和可扩展性。Spring的事件机制包括事件、事件发布、事件监听器等几个基本概念。

其中，事件是一个抽象的概念，它代表着应用程序中的某个动作或状态的发生。事件发布是事件发生的地方，它负责产生事件并通知事件监听器。事件监听器是事件的接收者，它负责处理事件并执行相应的操作。在Spring的事件机制中，事件源和事件监听器之间通过事件进行通信，从而实现了模块之间的解耦。

举个例子：用户修改密码，修改完密码后需要短信通知用户，记录关键性日志，等等其他业务操作。

如下图，就是我们需要调用多个服务来进行实现一个修改密码的功能。

使用了事件机制后，我们只需要发布一个事件，无需关心其扩展的逻辑，让我们的事件监听器去处理，从而实现了模块之间的解耦。

事件

通过继承ApplicationEvent，实现自定义事件。是对 Java EventObject 的扩展，表示 Spring 的事件，Spring 中的所有事件都要基于其进行扩展。其源码如下。

我们可以获取到timestamp属性指的是发生时间。

事件发布

事件发布是事件发生的地方，它负责产生事件并通知事件监听器。ApplicationEventPublisher用于用于发布 ApplicationEvent 事件，发布后 ApplicationListener 才能监听到事件进行处理。源码如下。

需要一个ApplicationEvent，就是我们的事件，来进行发布事件。

事件监听器

ApplicationListener 是 Spring 事件的监听器，用来接受事件，所有的监听器都必须实现该接口。该接口源码如下。

Spring的事件机制的使用方法

下面会给大家演示如何去使用Spring的事件机制。就拿修改密码作为演示。

如何定义一个事件

新增一个类，继承我们的ApplicationEvent。

如下面代码，继承后定义了一个userId，有一个UserChangePasswordEvent方法。这里就定义我们监听器需要的业务参数，监听器需要那些参数，我们这里就定义那些参数。

/**
 * @Author JiaQIng
 * @Description 修改密码事件
 * @ClassName UserChangePasswordEvent
 * @Date 2023/3/26 13:55
 **/
@Getter
@Setter
public class UserChangePasswordEvent extends ApplicationEvent {
    private String userId;

    public UserChangePasswordEvent(String userId) {
        super(new Object());
        this.userId = userId;
    }
}

如何监听事件

实现监听器有两种方法

1、新建一个类实现ApplicationListener接口，并且重写onApplicationEvent方法。注入到Spring容器中，交给Spring管理。如下代码。新建了一个发送短信监听器，收到事件后执行业务操作。

/**
 * @Author JiaQIng
 * @Description 发送短信监听器
 * @ClassName MessageListener
 * @Date 2023/3/26 14:16
 **/
@Component
public class MessageListener implements ApplicationListener<UserChangePasswordEvent> {

    @Override
    public void onApplicationEvent(UserChangePasswordEvent event) {
        System.out.println("收到事件:" + event);
        System.out.println("开始执行业务操作给用户发送短信。用户userId为：" + event.getUserId());
    }
}

2、使用 @EventListener 注解标注处理事件的方法，此时 Spring 将创建一个 ApplicationListener bean 对象，使用给定的方法处理事件。源码如下。参数可以给指定的事件。

这里巧妙的用到了@AliasFor的能力，放到了@EventListener身上注意：一般建议都需要指定此值，否则默认可以处理所有类型的事件，范围太广了。

代码如下。新建一个事件监听器，注入到Spring容器中，交给Spring管理。在指定方法上添加@EventListener参数为监听的事件。方法为业务代码。使用 @EventListener 注解的好处是一个类可以写很多监听器，定向监听不同的事件，或者同一个事件。

/**
 * @Author JiaQIng
 * @Description 事件监听器
 * @ClassName LogListener
 * @Date 2023/3/26 14:22
 **/
@Component
public class ListenerEvent {

    @EventListener({ UserChangePasswordEvent.class })
    public void LogListener(UserChangePasswordEvent event) {
        System.out.println("收到事件:" + event);
        System.out.println("开始执行业务操作生成关键日志。用户userId为：" + event.getUserId());
    }

    @EventListener({ UserChangePasswordEvent.class })
    public void messageListener(UserChangePasswordEvent event) {
        System.out.println("收到事件:" + event);
        System.out.println("开始执行业务操作给用户发送短信。用户userId为：" + event.getUserId());
    }
}

3、@TransactionalEventListener来定义一个监听器，他与@EventListener不同的就是@EventListener标记一个方法作为监听器，他默认是同步执行，如果发布事件的方法处于事务中，那么事务会在监听器方法执行完毕之后才提交。事件发布之后就由监听器去处理，而不要影响原有的事务，也就是说希望事务及时提交。我们就可以使用该注解来标识。注意此注解需要spring-tx的依赖。

注解源码如下：主要是看一下注释内容。

// 在这个注解上面有一个注解：`@EventListener`，所以表明其实这个注解也是个事件监听器。 
@Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@EventListener
public @interface TransactionalEventListener {

 /**
  * 这个注解取值有：BEFORE_COMMIT(指定目标方法在事务commit之前执行)、AFTER_COMMIT(指定目标方法在事务commit之后执行)、
  * AFTER_ROLLBACK(指定目标方法在事务rollback之后执行)、AFTER_COMPLETION(指定目标方法在事务完成时执行，这里的完成是指无论事务是成功提交还是事务回滚了)
  * 各个值都代表什么意思表达什么功能，非常清晰，
  * 需要注意的是：AFTER_COMMIT + AFTER_COMPLETION是可以同时生效的
  * AFTER_ROLLBACK + AFTER_COMPLETION是可以同时生效的
  */
 TransactionPhase phase() default TransactionPhase.AFTER_COMMIT;

 /**
  * 表明若没有事务的时候，对应的event是否需要执行，默认值为false表示，没事务就不执行了。
  */
 boolean fallbackExecution() default false;

 /**
  *  这里巧妙的用到了@AliasFor的能力，放到了@EventListener身上
  *  注意：一般建议都需要指定此值，否则默认可以处理所有类型的事件，范围太广了。
  */
 @AliasFor(annotation = EventListener.class, attribute = "classes")
 Class<?>[] value() default {};

 /**
  * The event classes that this listener handles.
  * <p>If this attribute is specified with a single value, the annotated
  * method may optionally accept a single parameter. However, if this
  * attribute is specified with multiple values, the annotated method
  * must <em>not</em> declare any parameters.
  */
 @AliasFor(annotation = EventListener.class, attribute = "classes")
 Class<?>[] classes() default {};

 /**
  * Spring Expression Language (SpEL) attribute used for making the event
  * handling conditional.
  * <p>The default is {@code ""}, meaning the event is always handled.
  * @see EventListener#condition
  */
 @AliasFor(annotation = EventListener.class, attribute = "condition")
 String condition() default "";

 /**
  * An optional identifier for the listener, defaulting to the fully-qualified
  * signature of the declaring method (e.g. "mypackage.MyClass.myMethod()").
  * @since 5.3
  * @see EventListener#id
  * @see TransactionalApplicationListener#getListenerId()
  */
 @AliasFor(annotation = EventListener.class, attribute = "id")
 String id() default "";

}

使用方式如下。phase事务类型，value指定事件。

/**
 * @Author JiaQIng
 * @Description 事件监听器
 * @ClassName LogListener
 * @Date 2023/3/26 14:22
 **/
@Component
public class ListenerEvent {

    @EventListener({ UserChangePasswordEvent.class })
    public void logListener(UserChangePasswordEvent event) {
        System.out.println("收到事件:" + event);
        System.out.println("开始执行业务操作生成关键日志。用户userId为：" + event.getUserId());
    }

    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT,value = { UserChangePasswordEvent.class })
    public void messageListener(UserChangePasswordEvent event) {
        System.out.println("收到事件:" + event);
        System.out.println("开始执行业务操作给用户发送短信。用户userId为：" + event.getUserId());
    }
}

如何发布一个事件

1、使用ApplicationContext进行发布，由于ApplicationContext已经继承了 ApplicationEventPublisher ，因此可以直接使用发布事件。源码如下

2、直接注入我们的ApplicationEventPublisher，使用@Autowired注入一下。

三种发布事件的方法，我给大家演示一下@Autowired注入的方式发布我们的事件。

@SpringBootTest
class SpirngEventApplicationTests {
    @Autowired
    ApplicationEventPublisher appEventPublisher;
    @Test
    void contextLoads() {
        appEventPublisher.publishEvent(new UserChangePasswordEvent("1111111"));
    }

}

我们执行一下看一下接口。

测试成功。

搭配@Async注解实现异步操作

监听器默认是同步执行的，如果我们想实现异步执行，可以搭配@Async注解使用，但是前提条件是你真的懂@Async注解，使用不当会出现问题的。后续我会出一篇有关@Async注解使用的文章。这里就不给大家详细的解释了。有想了解的同学可以去网上学习一下有关@Async注解使用。

使用@Async时，需要配置线程池，否则用的还是默认的线程池也就是主线程池，线程池使用不当会浪费资源，严重的会出现OOM事故。

下图是阿里巴巴开发手册的强制要求。

简单的演示一下：这里声明一下俺没有使用线程池，只是简单的演示一下。

1、在我们的启动类上添加@EnableAsync开启异步执行配置

@EnableAsync
@SpringBootApplication
public class SpirngEventApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpirngEventApplication.class, args);
    }

}

2、在我们想要异步执行的监听器上添加@Async注解。

/**
 * @Author JiaQIng
 * @Description 事件监听器
 * @ClassName LogListener
 * @Date 2023/3/26 14:22
 **/
@Component
public class ListenerEvent {
    
    @Async
    @EventListener({ UserChangePasswordEvent.class })
    public void logListener(UserChangePasswordEvent event) {
        System.out.println("收到事件:" + event);
        System.out.println("开始执行业务操作生成关键日志。用户userId为：" + event.getUserId());
    }
}

这样我们的异步执行监听器的业务操作就完成了。

Spring的事件机制的应用场景

告警操作，比喻钉钉告警，异常告警，可以通过事件机制进行解耦。
关键性日志记录和业务埋点，比喻说我们的关键日志需要入库，记录一下操作时间，操作人，变更内容等等，可以通过事件机制进行解耦。
性能监控，比喻说一些接口的时长，性能方便的埋点等。可以通过事件机制进行解耦。
.......一切与主业务无关的操作都可以通过这种方式进行解耦，常用的场景大概就上述提到的，而且很多架构的源码都有使用这种机制，如GateWay，Spring等等。

Spring的事件机制的注意事项

对于同一个事件，有多个监听器的时候，注意可以通过@Order注解指定顺序，Order的value值越小，执行的优先级就越高。
如果发布事件的方法处于事务中，那么事务会在监听器方法执行完毕之后才提交。事件发布之后就由监听器去处理，而不要影响原有的事务，也就是说希望事务及时提交。我们就可以 @TransactionalEventListener来定义一个监听器。
监听器默认是同步执行的，如果我们想实现异步执行，可以搭配@Async注解使用，但是前提条件是你真的懂@Async注解，使用不当会出现问题的。
对于同一个事件，有多个监听器的时候，如果出现了异常，后续的监听器就失效了，因为他是把同一个事件的监听器add在一个集合里面循环执行，如果出现异常，需要注意捕获异常处理异常。

后记

此文章主要是讲解什么是Spring的事件机制，怎么使用Spring事件机制，工作中的场景有哪些。

源码：https://github.com/hujiaqing789/spring-boot-study.git

芋道源码 —— 纯源码解析博客

使用上 Spring 的事件机制，真香！

前言