Spring事件处理

谁借莪１个温暖的怀抱￠ 2024-03-30 10:48 46阅读 0赞

在实际业务开发中，有时候复杂性的业务之间需要解耦，常用的方法：同步、异步、MQ。但 MQ 重啊，非必要不提升架构复杂度。

针对同步和异步使用方式：１.定时器　２.Spring Event.

Spring Event:

观察者设计模式，一个 Bean 处理完成任务后希望通知其它 Bean 或者说一个 Bean监听另一个Bean 的行为。

配置异步线程池

package com.lean.event.demo.config;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.scheduling.annotation.AsyncConfigurer;
    import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
    
    import java.util.concurrent.Executor;
    import java.util.concurrent.ThreadPoolExecutor;
    
    @Configuration
    public class AsynConfig implements AsyncConfigurer {
    
        private static final Logger log= LoggerFactory.getLogger(AsynConfig.class);
    
        @Bean("taskAsyncPool")
        public Executor orderTaskAsyncPool() {
            ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
            executor.setCorePoolSize(10); // 核心线程数
            executor.setMaxPoolSize(20); // 最大线程数
            executor.setQueueCapacity(1000); // 队列大小
            executor.setKeepAliveSeconds(300); // 线程最大空闲时间
            executor.setThreadNamePrefix("async-Executor-"); // 指定用于新创建的线程名称的前缀。
            executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy()); // 拒绝策略（一共四种，此处省略）
            executor.initialize();
            return executor;
        }
    
        @Override
        public Executor getAsyncExecutor() {
            return orderTaskAsyncPool();
        }
    
        // 异常处理器
        @Override
        public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
            return (ex, method, params) -> log.error(String.format("执行异步任务'%s'", method), ex);
        }
    }

**1.同步**

import lombok.Getter;
    import lombok.Setter;
    import lombok.ToString;
    import org.springframework.context.ApplicationEvent;
    /**
     * 自定义事件 继承ApplicationEvent
     */
    @Getter
    @Setter
    @ToString
    public class MessageEvent extends ApplicationEvent {
        //传输的数据对象
        private String messageId;
        public MessageEvent(Object source, String messageId) {
            super(source);
            this.messageId = messageId;
        }
    }

package com.lean.event.demo.listener;
    
    
    import com.lean.event.demo.events.MessageEvent;
    import lombok.SneakyThrows;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.context.ApplicationListener;
    import org.springframework.stereotype.Component;
    /**
     * 同步
     * 监听器：
     * 实现方式：
     *      1.实现ApplicationListener
     *      2.@EventListener
     */
    @Slf4j
    @Component
    public class MessageListener implements ApplicationListener<MessageEvent> {
        @SneakyThrows
        @Override
        public void onApplicationEvent(MessageEvent event) {
            String messageId = event.getMessageId();
            long start = System.currentTimeMillis();
            long end = System.currentTimeMillis();
            log.info("{}：耗时：({})毫秒", messageId, (end - start));
        }
    }

**2.异步**

**| 自定义事件**

import lombok.AllArgsConstructor;
    import lombok.Data;
    
    
    @Data
    @AllArgsConstructor
    public class MsgEvent {
        /**
         * 该类型事件携带的信息
         */
        public String messageId;
    }

import com.lean.event.demo.events.MsgEvent;
    import lombok.SneakyThrows;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.context.event.EventListener;
    import org.springframework.scheduling.annotation.Async;
    import org.springframework.stereotype.Component;
    @Slf4j
    @Component
    public class MsgListener {
    
        //异步注解 需要开启@EnableAsync异步
        @Async(value = "taskAsyncPool")
        @SneakyThrows
        @EventListener(MsgEvent.class)
        public void sendMsg(MsgEvent event) {
            String messageId = event.getMessageId();
            long start = System.currentTimeMillis();
            log.info("开发发送短信");
            log.info("开发发送邮件");
            long end = System.currentTimeMillis();
            log.info("{}：发送短信、邮件耗时：({})毫秒", messageId, (end - start));
        }
    }

import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.scheduling.annotation.EnableAsync;
    
    @EnableAsync
    @SpringBootApplication
    public class SpringLeanEventApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(SpringLeanEventApplication.class, args);
        }
    
    }

**3.测试**

package com.lean.event.demo.service;
    
    import com.lean.event.demo.events.MsgEvent;
    import com.lean.event.demo.events.MessageEvent;
    import lombok.Data;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.context.ApplicationContext;
    import org.springframework.stereotype.Service;
    @Slf4j
    @Service
    @Data
    public class MessageService {
        /** 注入ApplicationContext用来发布事件 */
        private final ApplicationContext applicationContext;
        public String testMessage(String messageId) {
            long start = System.currentTimeMillis();
            // （同步处理）
            applicationContext.publishEvent(new MessageEvent(this, messageId));
            // （异步处理）
            applicationContext.publishEvent(new MsgEvent(messageId));
            long end = System.currentTimeMillis();
            log.info("任务全部完成，总耗时：({})毫秒", end - start);
            return "购买成功";
        }
    }

package com.lean.event.demo;
    
    
    import com.lean.event.demo.service.MessageService;
    import org.junit.jupiter.api.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    
    @SpringBootTest
    public class MessageServiceTest {
    
        @Autowired
        private MessageService messageService;
        @Test
        public void buyOrderTest() {
            messageService.testMessage("123456");
        }
    }

## ApplicationEvent: ##

类的注释是，被应用事件继承的类，抽象的不能初始化；

![42ae27a1d3034a55a25214a7e33e6001.png][]

**EventObject: 父类**

![5629c58ce5e24553998d50b951f3f8ec.png][]

事件携带一个 Objecgt 对象，可以被发布。

事件监听者，监听到这个事件后，触发自定义逻辑 ( 操作 Object 对象)；

注意：

**事件发布后，都会被监听ApplicationEvent的监听对象所监听到。**

[代码][Link 1]

[42ae27a1d3034a55a25214a7e33e6001.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/0acf30314dd6478db04452bb0c2bc638.png
[5629c58ce5e24553998d50b951f3f8ec.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/749d5d7e0ebf4eb6bba960746f73777a.png
[Link 1]: https://gitee.com/zhw123/java-write-frame/tree/master/spring-lean-event