Spring中的事件

Spring框架中的事件

spring中的事件通过观察者模式实现的。在spring容器中通过ApplicationEvent类和ApplicationListener接口处理事件，如果某个bean实现了ApplicationListener接口并部署到容器中，那么每次对应的ApplicationEvent被发布到容器中都会通知该bean。

spring事件默认是同步的，即调用publishEvent方法发布事件后，会处于阻塞状态，直到onApplicationEvent接收到事件并处理返回之后才继续执行下去。

ApplicationEvent

表示事件本身，自定义事件需要继承该类,可以用来传递数据,比如上述操作,我们需要将用户的邮箱地址传给事件监听器.

ApplicationListener

事件监听器接口,事件的业务逻辑封装在监听器里面.

ApplicationEventPublisherAware

事件发送器,通过实现这个接口,来触发事件.

实例

现在通过一个例子来说明一下。假如用户登录之后，需要发送邮件、推荐商品、插入用户信息

定义事件：UserRegisterEvent

定义监听器：NotifyUserListener（发邮件）、RecommendListener（推荐商品）、UserInsertListener（插入用户信息）

@Data
@ToString
public class User {
    private String name;
    private String age;
    private String phone;
}

@ToString
@Getter
@Setter
public class UserRegisterEvent extends ApplicationEvent {
    /**
     * Create a new ApplicationEvent.
     *
     * @param source the object on which the event initially occurred (never {@code null})
     */
    public UserRegisterEvent(Object source) {
        super(source);
    }
    public void sayHello(){
        System.out.println("hello spring event");
    }
    private User user;
}

@Component
public class NotifyUserListener implements ApplicationListener<UserRegisterEvent> {
    @Override
    public void onApplicationEvent(UserRegisterEvent event) {
        System.out.println("NotifyUserListener:onApplicationEvent()");
        UserRegisterEvent userRegisterEvent = event;
        System.out.println("发送邮件...");
    }
}

@Component
public class RecommendListener implements ApplicationListener<UserRegisterEvent> {
    @Override
    public void onApplicationEvent(UserRegisterEvent event) {
        System.out.println("RecommendListener:onApplicationEvent()");
        UserRegisterEvent userRegisterEvent = event;
        System.out.println("推荐商品...");
    }
}

@Component
public class UserInsertListener implements ApplicationListener<UserRegisterEvent> {
    @Override
    public void onApplicationEvent(UserRegisterEvent event) {
        System.out.println("UserInsertListener:onApplicationEvent()");
        UserRegisterEvent userRegisterEvent = event;
        System.out.println("插入用户信息,用户名..." + userRegisterEvent.getUser().getName());
    }
}

@Component
public class UserRegisterPublisherService implements ApplicationEventPublisherAware {
    private ApplicationEventPublisher applicationEventPublisher;

    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
        this.applicationEventPublisher = applicationEventPublisher;
    }

    public void insert(User user) {
        UserRegisterEvent event = new UserRegisterEvent(JSON.toJSONString(user));
        applicationEventPublisher.publishEvent(event);
    }

    public void publish() {
        UserRegisterEvent ce = new UserRegisterEvent(this);
        User user = new User();
        user.setName("YO");
        user.setAge("1000");
        ce.setUser(user);
        System.out.println("UserRegisterPublisherService: publish");
        applicationEventPublisher.publishEvent(ce);
    }
}

/**
 * @author gyh
 * @description //自动扫描包名下所有使用@Component、@Service、@Repository和@Controller的类，并注册为Bean
 * @create 2020/10/28
 */
@Configuration
@ComponentScan("com.event")
public class EventConfig {
}

public class MainApp {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(EventConfig.class);
        UserRegisterPublisherService registerPublisherService = context.getBean(UserRegisterPublisherService.class);
        System.out.println("start");
        System.out.println("用户已登录...");
        registerPublisherService.publish();
        context.close();
        System.out.println("end");
    }
}

start
用户已登录...
发送邮件...
RecommendListener:onApplicationEvent()
推荐商品...
UserInsertListener:onApplicationEvent()
插入用户信息,用户名...YO
end

SmartApplicationListener实现有序的监听

SmartApplicationListener接口继承了ApplicationListener接口，使用全局的ApplicationEvent作为监听的对象。

像比于ApplicationListener提供了排序功能、校验是否是我们监听的事件，是通过两个方法#supportsEventType、#supportsSourceType 来判定，只有这两个方法同时返回true时才会执行onApplicationEvent方法。

package com.smartEvent;

import org.springframework.context.ApplicationEvent;
import org.springframework.context.event.SmartApplicationListener;
import org.springframework.stereotype.Component;

@Component
public class NotifyUserListener implements SmartApplicationListener {
    @Override
    public boolean supportsEventType(Class<? extends ApplicationEvent> eventType) {
        return eventType == UserRegisterEvent.class;
    }

    @Override
    public boolean supportsSourceType(Class<?> sourceType) {
        return true;
    }

    @Override
    public void onApplicationEvent(ApplicationEvent event) {
        System.out.println("NotifyUserListener:onApplicationEvent()");
        UserRegisterEvent userRegisterEvent = (UserRegisterEvent) event;
        System.out.println("发送邮件...");
    }

    @Override
    public int getOrder() {
        return 2;
    }
}

还可以使用注解的方式实现

package com.smartEvent;

import org.springframework.context.event.EventListener;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Component
public class UserInsertListener {
    @Order(1)
    @EventListener(classes = com.smartEvent.UserRegisterEvent.class)
    public void onApplicationEvent(UserRegisterEvent event) {
        System.out.println("UserInsertListener:onApplicationEvent()");
        System.out.println("插入用户信息,用户名..." + event.getUser().getName());
    }
}

异步事件

spring事件默认是同步的，同步事件会使得ApplicationEventPublisher 发布事件之后一直等待listener 响应，如果耗时过长会影响用户体验，根据需要也可以将事件配置为异步方式。

可以使用Spring 提供的线程池注解 @Async 来实现异步线程。使用这个注解实现异步线程有个前提， 要在启动类商添加@EnableAsync 注解。如果不先使用系统提供的线程池配置，也可以通过下面的方法手动指定

package com.asyncEvent;

import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.*;


@Configuration
@EnableAsync
public class ThreadPoolConfig {

    /**
     * 线程池【方式1】
     */
    @Bean(value = "executeThreadPool")
    public Executor executeSettlementThreadPool() {

        ThreadFactory threadFactory = new ThreadFactoryBuilder()
                .setNameFormat("execute-settlement-thread-%d").build();

        ExecutorService pool = new ThreadPoolExecutor(5, 10, 30L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>(10000), threadFactory, new ThreadPoolExecutor.AbortPolicy());

        return pool;
    }
    /**
     * 线程池【方式二】
     */
    @Bean(value = "executeThreadPoolV2")
    public Executor executeSettlementThreadPoolV2() {

        ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()
                .setNameFormat("consumer-queue-thread-%d").build();
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 线程池维护线程的最少数量
        executor.setCorePoolSize(5);
        // 线程池维护线程的最大数量
        executor.setMaxPoolSize(10);
        // 缓存队列
        executor.setQueueCapacity(25);
        //线程名
        executor.setThreadFactory(namedThreadFactory);
        // 线程池初始化
        executor.initialize();
        return executor;
    }
}

在每个listener中打印当前线程id，并将插入用户信息的listener改为异步方式

package com.asyncEvent;

import org.springframework.context.event.EventListener;
import org.springframework.core.annotation.Order;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

@Component
public class UserInsertListener {
    @Async("executeThreadPool")
    @Order(1)
    @EventListener(classes = UserRegisterEvent.class)
    public void onApplicationEvent(UserRegisterEvent event) {
        System.out.println("UserInsertListener:onApplicationEvent()");
        System.out.println("current thread id:"+Thread.currentThread().getId());
        System.out.println("插入用户信息,用户名..." + event.getUser().getName());
    }
}

运行结果：

start
用户已登录...
UserRegisterPublisherService: publish
NotifyUserListener:onApplicationEvent()
current thread id:1
发送邮件...
RecommendListener:onApplicationEvent()
current thread id:1
推荐商品...
current thread id:1 
end
UserInsertListener:onApplicationEvent()
current thread id:11
插入用户信息,用户名...YO

Process finished with exit code 0

可以看到插入用户信息的listener的线程id变成了11，其余都是1，就实现了异步方式的事件监听。

参考博客

https://www.cnblogs.com/rickiyang/p/12001524.html 作者：rickiyang