浅谈springboot2.0 监听器Listener之异步监听

- 日理万妓 2022-04-05 14:54 915阅读 0赞

声明：使用 springboot2.1.1进行测试、  
》

Listener是JavaWeb的三大组件（Servlet、Filter、Listener）之一，JavaWeb中的监听器主要用于监听：ServletContext、HttpSession、ServletRequest 的生命周期以及属性变化；在spring中也提供了监听器公开发人员使用；

其实现原理是设计模式之观察者模式，设计的初衷是为了系统业务之间进行解耦，以便提高系统可扩展性、可维护性。Listener 主要包括定义事件、事件监听、事件发布

> 事件监听：
> 
>  *  同步监听：
>  *  异步监听 ：
> 
> 下面写几个监听器的demo  
> / 源码分享、  
> [https://github.com/medoo-Ai/boot-demo][https_github.com_medoo-Ai_boot-demo]

Spring Boot 2.0 以后定义的事件：

ApplicationFailedEvent：Spring Boot 启动失败时触发；  
ApplicationPreparedEvent：上下文 Context 准备时触发；  
ApplicationReadyEvent：上下文准备完毕的时触发；  
ApplicationStartedEvent：Spring Boot 启动监听类；  
SpringApplicationEvent：获取 SpringApplication；  
ApplicationEnvironmentPreparedEvent：装配完参数和环境后触发的事件。

> 项目结构如下，pojo 如图，下面不再贴出，有不清楚请了留言或者参考GitHub源代码、

![6][]

##### 1、同步监听 #####

1、模拟用户注册事件，对其进行监听、

> 代码步骤：  
> 1、用户注册  
> 2、编写controller、service业务  
> 3、监听  
> 456

1、用户注册事件 UserRegisterEvent

/** * @auther SyntacticSugar * @data 2018/12/12 0012上午 11:20 */
    public @Data class UserRegisterEvent extends ApplicationEvent { 
    // user注册用户、source 事件源
        private User user;
        public UserRegisterEvent(Object source,User user ) { 
            super(source);
            this.user=user;
        }
    }

2、 controller  
访问路径 user/register

@RestController
    @RequestMapping("user")
    public class UserController { 
        @Autowired
        private UserService userService;
        @GetMapping("register")
        public String registerUser(@NotNull String username,@NotNull Integer age){ 
            // 返回注册 success or fail
            String msg="success";
            try { 
                userService.registerUser(new User(username,age));
            } catch (Exception e) { 
                msg="fail";
                e.printStackTrace();
            }
            return msg;
        }
    }

3、业务UserService 接口以及实现类UserServiceImpl 、

public interface UserService { 
        void registerUser(User user);
    }
    
    /** * @auther SyntacticSugar * @data 2018/12/12 0012上午 11:25 */
    @Service("userService")
    public class UserServiceImpl implements UserService { 
        @Autowired
        private ApplicationContext applicationContext;
    
        @Override
        public void registerUser(User user) { 
            // 若用户不为null，发布用户注册事件
            if (null!=user) { 
                applicationContext.publishEvent(new UserRegisterEvent(this, user));
            }
        }
    }

4、监听 用户注册事件 UserRegisterEvent

> 有三种方式进行同步监听：  
> 1、@EventListener 注解  
> 2、实现接口ApplicationListener  
> 3、实现接口SmartApplicationListener

使用注解  进行监听事件

@Component
    public class AnnotationUserRegisterListener { 
        // 监听用户注册事件
        @EventListener
        public  void sendMailToUser(UserRegisterEvent userRegisterEvent){ 
            System.out.println("---------------------------");
            System.out.println("利用@EventListener注解监听用户注册事件并向用户发送邮件");
            System.out.println("注册用户名：" + userRegisterEvent.getUser().getUsername());
        }
    }

实现接口ApplicationListener

@Component
    public class RegisterUserApplicationListener  implements ApplicationListener<UserRegisterEvent> { 
        @Override
        public void onApplicationEvent(UserRegisterEvent userRegisterEvent) { 
            System.out.println("---------------------------");
            System.out.println("实现ApplicationListener接口监听userRegisterEvent 并向用户发邮箱");
            System.out.println("注册的用户名字"+userRegisterEvent.getUser().getUsername());
        }
    }

实现接口SmartApplicationListener

@Component
    public class RegisterUserSmartApplicationListener implements SmartApplicationListener { 
    
        @Override
        public boolean supportsEventType(Class<? extends ApplicationEvent> aClass) { 
            return aClass== UserRegisterEvent.class;
        }
    
        @Override
        public boolean supportsSourceType(Class<?> sourceType) { 
            // 事件源 、 和service的实现类
            return sourceType== UserServiceImpl.class;
        }
    
        @Override
        public int getOrder() { 
            return 1;
        }
    
        @Override
        public void onApplicationEvent(ApplicationEvent applicationEvent) { 
            UserRegisterEvent userRegisterEvent =(UserRegisterEvent)applicationEvent;
            System.out.println("---------------------------");
            System.out.println("实现SmartApplicationListener接口进行监听");
            System.out.println("向用户发送邮箱"+userRegisterEvent.getUser().getUsername());
        }
    }

> 访问：  
> [http://localhost:8011/user/register?username=doudou&age=15][http_localhost_8011_user_register_username_doudou_age_15]  
> 如下，监听有效  
> 但是是同步监听、  
> 也就是说，监听整个完成以后，业务逻辑才算完成；那么，当业务逻辑比较复杂时候，用户体验比较差；下面采用一种异步监听的方式；

![5][]

##### 2、异步监听 #####

> 使用 @Async 注解 ，完成事件的异步监听、

1、给监听器设置异步线程池对象 AsyncListenerConfiguration ：

@Configuration
    @EnableAsync
    public class AsyncListenerConfiguration implements AsyncConfigurer { 
    
        @Override
        public Executor getAsyncExecutor() { 
            ThreadPoolTaskExecutor poolTE = new ThreadPoolTaskExecutor();
            // 设置线程池的数目
            poolTE.setCorePoolSize(10);
            poolTE.setMaxPoolSize(20);
            poolTE.setQueueCapacity(50);
            poolTE.initialize();
            return poolTE;
        }
        @Override
        public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() { 
            return null;
        }
    }

2、设置监听器 AsyncAnnotationUserRegisterListener 异步监听用户注册事件

/** * @auther SyntacticSugar * @data 2018/12/12 0012下午 12:16 */
    @Component
    public class AsyncAnnotationUserRegisterListener { 
        // 异步监听的方法上面 添加 async注解
        @Async
        @EventListener
       public void  sendMailToUser(UserRegisterEvent userRegisterEvent){ 
                // 线程
            try { 
                Thread.sleep(5000);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            System.out.println("通过异步监听 "+ userRegisterEvent.getUser().getUsername());
       }
    }

> 访问：  
> [http://localhost:8011/user/register?username=doudou&age=15][http_localhost_8011_user_register_username_doudou_age_15]

![3][]

##### 3、初始化bean监听 #####

> 通常，在上下文和 Bean 创建成功后做一些初始化缓存等操作、下面利用监听ApplicationReadyEvent 事件完成如下操作：  
> main 函数启动后，开始初始化 Redis 缓存、

1、在main 函数中添加 监听器Listener、

@SpringBootApplication
    public class BootDemoApplication { 
    
        public static void main(String[] args) { 
            // 添加监听器
            SpringApplication springApplication = new SpringApplication(BootDemoApplication.class);
            springApplication.addListeners(new InitializeRedisCacheListener());
            springApplication.run(args);
        }
    }

2、 定义监听器 InitializeRedisCacheListener ，监听ApplicationReadyEvent事件

// 初始化 redis 缓存
        // 把 listner 注册到 启动main 中
    
    public class InitializeRedisCacheListener implements ApplicationListener<ApplicationReadyEvent> { 
    
        @Override
        public void onApplicationEvent(ApplicationReadyEvent applicationReadyEvent) { 
            // 获取redisUtil ，若其不为null 初始化redis
            ConfigurableApplicationContext applicationContext = applicationReadyEvent.getApplicationContext();
            RedisUtil redisUtil = applicationContext.getBean(RedisUtil.class);
            if (null!=redisUtil) { 
                redisUtil.initializeRedisData();
            }
    
        }
    }

redisUtil  写的是伪代码；

/** * @auther SyntacticSugar * @data 2018/12/12 0012下午 12:30 */
    @Component
    public class RedisUtil { 
        public void initializeRedisData() { 
            System.out.println("初始化redis 缓存");
            try { 
                Thread.sleep(5000);
            }
            catch (Exception e){ 
    
            }
        }
    }

[https_github.com_medoo-Ai_boot-demo]: https://github.com/medoo-Ai/boot-demo
[6]: /images/20220405/34bf63b3dde64aec9ed99c88b7375a76.png
[http_localhost_8011_user_register_username_doudou_age_15]: http://localhost:8011/user/register?username=doudou&age=15
[5]: /images/20220405/ef33aa35008c42308ed9156f76e3f399.png
[3]: /images/20220405/60fcdd6ac88c47ee80b620b70b0be41c.png