Springboot 框架中事件监听和发布机制详细介绍

开发 前端
Spring Framework中的ApplicationEventPublisher​接口用于发布和订阅应用程序事件。事件是一种机制,用于在应用程序中实现松散耦合的组件通信。当某些事件发生时,发布者可以通知所有已注册的监听器,并执行相应的操作。

事件监听和发布是Spring Framework中的一种机制,用于实现松散耦合的组件之间的通信。下面是事件监听和发布的详细过程:

事件发布的过程:

  1. 创建事件对象:首先,您需要创建一个事件类,通常继承自ApplicationEvent。这个事件类用于封装事件的相关信息。
  2. 创建事件发布者:您需要创建一个事件发布者(通常是一个Spring Bean),该发布者包含一个注入的ApplicationEventPublisher接口,用于发布事件。
  3. 发布事件:在需要发布事件的地方,事件发布者调用publishEvent()方法,并将创建的事件对象作为参数传递给该方法。Spring容器会负责将事件传递给所有已注册的监听器。
  4. 事件传播:Spring容器会遍历所有已注册的事件监听器,将事件传递给每个监听器。监听器的onApplicationEvent()方法会被调用,处理事件。

事件监听的过程:

  1. 创建事件监听器:您需要创建一个或多个事件监听器,这些监听器通常实现ApplicationListener接口。每个监听器负责处理特定类型的事件。
  2. 注册监听器:事件监听器需要在Spring容器中注册,以便Spring知道它们存在。您可以使用@Component注解或配置类中的@Bean注解进行注册。
  3. 事件监听器的初始化:当应用程序启动时,Spring容器会初始化所有注册的监听器。
  4. 等待事件:监听器会一直等待与其关联的事件被发布。当事件被发布时,监听器会被调用以处理事件。
  5. 处理事件:监听器实现的onApplicationEvent()方法会被调用,事件对象会作为参数传递给该方法。监听器可以根据事件的信息执行相应的操作。

Spring Framework中的ApplicationEventPublisher接口用于发布和订阅应用程序事件。事件是一种机制,用于在应用程序中实现松散耦合的组件通信。当某些事件发生时,发布者可以通知所有已注册的监听器,并执行相应的操作。下面是ApplicationEventPublisher的详细用法说明和示例代码:

创建自定义事件类:

首先,需要创建一个自定义事件类,继承自ApplicationEvent。这个事件类将包含希望在应用程序中发布的事件的信息。

import org.springframework.context.ApplicationEvent;

public class MyCustomEvent extends ApplicationEvent {
    private String message;

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

    public String getMessage() {
        return message;
    }
}

创建事件发布者:

事件发布者通常是Spring容器中的一个Bean,它使用ApplicationEventPublisher来发布事件。可以注入ApplicationEventPublisher接口以在需要时发布事件。

import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Component;

@Component
public class MyEventPublisher {

    private final ApplicationEventPublisher eventPublisher;

    public MyEventPublisher(ApplicationEventPublisher eventPublisher) {
        this.eventPublisher = eventPublisher;
    }

    public void publishCustomEvent(String message) {
        MyCustomEvent customEvent = new MyCustomEvent(this, message);
        eventPublisher.publishEvent(customEvent);
    }
}

创建事件监听器:

事件监听器负责处理事件。可以创建一个或多个事件监听器,每个监听器可以处理不同类型的事件。

import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

@Component
public class MyEventListener implements ApplicationListener<MyCustomEvent> {

    @Override
    public void onApplicationEvent(MyCustomEvent event) {
        String message = event.getMessage();
        // 处理事件
        System.out.println("Received custom event with message: " + message);
    }
}

使用事件发布者发布事件:

在需要发布事件的地方,可以调用事件发布者的方法来触发事件。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class MyApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(MyApplication.class, args);
        
        MyEventPublisher eventPublisher = context.getBean(MyEventPublisher.class);
        eventPublisher.publishCustomEvent("Hello, Spring Boot Events!");
    }
}

当运行MyApplication时,事件发布者将发布一个自定义事件,然后事件监听器将收到事件并执行相应的操作。

也可以创建同步和异步事件监听器,以便在事件发生时执行不同的操作。同步监听器会在事件发布线程中直接执行,而异步监听器则会将事件处理委托给另一个线程池,以实现并发处理。下面是同步和异步事件监听的示例说明:

同步事件监听器示例:

import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

@Component
public class MySyncEventListener implements ApplicationListener<MyCustomEvent> {
    @Override
    public void onApplicationEvent(MyCustomEvent event) {
        String message = event.getMessage();
        // 模拟一个长时间运行的操作
        try {
            Thread.sleep(2000); // 模拟2秒的处理时间
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Synchronous Event Listener - Received custom event with message: " + message);
    }
}

在这个示例中,MySyncEventListener是一个同步事件监听器。它在onApplicationEvent()方法中执行了一个模拟的长时间运行的操作(2秒)。

异步事件监听器示例:

要创建异步事件监听器,需要使用@Async注解来标记监听器方法,然后配置一个TaskExecutorbean,以便Spring可以在异步线程池中执行监听器方法。以下是一个示例:

import org.springframework.context.ApplicationListener;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

@Component
public class MyAsyncEventListener implements ApplicationListener<MyCustomEvent> {
    @Async
    @Override
    public void onApplicationEvent(MyCustomEvent event) {
        String message = event.getMessage();
        // 模拟一个长时间运行的操作
        try {
            Thread.sleep(2000); // 模拟2秒的处理时间
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Asynchronous Event Listener - Received custom event with message: " + message);
    }
}

在这个示例中,MyAsyncEventListener是一个异步事件监听器。它的onApplicationEvent()方法被标记为@Async,并且在方法内模拟了一个长时间运行的操作。

配置异步事件监听:

要配置异步事件监听器,需要执行以下步骤:

在Spring Boot应用程序的主类上使用@EnableAsync注解以启用异步支持。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync;

@SpringBootApplication
@EnableAsync
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

在配置类或主类中定义一个TaskExecutor bean,以配置异步线程池。

import org.springframework.context.annotation.Bean;
import org.springframework.core.task.TaskExecutor;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

@Bean
public TaskExecutor taskExecutor() {
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    executor.setCorePoolSize(5); // 设置核心线程数
    executor.setMaxPoolSize(10); // 设置最大线程数
    executor.setQueueCapacity(25); // 设置队列容量
    executor.setThreadNamePrefix("MyAsyncThread-");
    executor.initialize();
    return executor;
}

通过以上配置,MyAsyncEventListener将会在异步线程中处理事件,而不会阻塞主线程。

请注意,异步监听器的配置可能因应用程序的需求而有所不同。我们可以根据需要调整线程池的大小和其他参数。

示例中完整代码,可以从下面网址获取:

https://gitee.com/jlearning/wechatdemo.git

https://github.com/icoderoad/wxdemo.git

责任编辑:武晓燕 来源: 路条编程
相关推荐

2010-08-06 10:03:42

Flex事件

2020-05-27 20:25:47

SpringSpringBoot数据

2010-08-09 09:47:34

Flex事件机制

2011-07-21 17:02:48

JAVA模式框架

2010-08-09 11:06:01

Flex事件机制

2010-07-29 10:33:59

Flex键盘事件

2011-07-11 11:02:12

JAVA集合框架

2011-07-14 11:08:30

C#继承

2009-06-19 14:49:43

Spring框架

2019-02-26 10:33:24

快应用

2009-12-23 16:06:46

WPF事件策略

2010-08-06 09:56:06

Flex事件机制

2011-06-28 12:39:34

Java垃圾回收

2009-12-15 18:39:36

Ruby Active

2011-07-21 15:20:41

java异常处理机制

2011-07-22 16:50:05

JAVA

2017-12-21 15:42:08

iOS传递机制

2011-07-05 17:29:56

2023-02-09 08:35:39

Spring嵌入式容器

2009-06-24 13:50:29

JSF和MVC
点赞
收藏

51CTO技术栈公众号