【1、spring事件】相关

最新推荐文章于 2024-07-12 09:16:51 发布
最新推荐文章于 2024-07-12 09:16:51 发布
阅读量97 收藏
点赞数
分类专栏： 笔记 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/d_xia/article/details/128547355
版权

spring

一、【spring事件】相关

1.观察者模式【行为型模式】

  • 1.1、定义

    • 又被称为发布-订阅（Publish/Subscribe）模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态变化时，会通知所有的观察者对象，使他们能够自动更新自己。

  • 1.2结构

    在观察者模式中有如下角色：

    • Subject：抽象主题（抽象被观察者），抽象主题角色把所有观察者对象保存在一个集合里，每个主题都可以有任意数量的观察者，抽象主题提供一个接口，可以增加和删除观察者对象。
    • ConcreteSubject：具体主题（具体被观察者），该角色将有关状态存入具体观察者对象，在具体主题的内部状态发生改变时，给所有注册过的观察者发送通知。
    • Observer：抽象观察者，是观察者的抽象类，它定义了一个更新接口，使得在得到主题更改通知时更新自己。
    • ConcrereObserver：具体观察者，实现抽象观察者定义的更新接口，以便在得到主题更改通知时更新自身的状态。

  • 1.3、优缺点

    1，优点：

    • 降低了目标与观察者之间的耦合关系，两者之间是抽象耦合关系。
    • 被观察者发送通知，所有注册的观察者都会收到信息【可以实现广播机制】

    2，缺点：

    • 如果观察者非常多的话，那么所有的观察者收到被观察者发送的通知会耗时
    • 如果被观察者有循环依赖的话，那么被观察者发送通知会使观察者循环调用，会导致系统崩溃

  • 1.4、使用场景

    • 对象间存在一对多关系，一个对象的状态发生改变会影响其他对象。
    • 当一个抽象模型有两个方面，其中一个方面依赖于另一方面时。

2、适配器模式（结构型模式）

  • 2.1、定义
    • 将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作。
  • 2.2、结构
    • 目标（Target）接口：当前系统业务所期待的接口，它可以是抽象类或接口。
    • 适配者（Adaptee）类：它是被访问和适配的现存组件库中的组件接口。
    • 适配器（Adapter）类：它是一个转换器，通过继承或引用适配者的对象，把适配者接口转换成目标接口，让客户按目标接口的格式访问适配者。

ctrl+shift+alt+n：全局查找器查找所有的类

3、spring事件

3.1、事件监听的3种方式

  • 1、实现 ApplicationListener 接口

    • 根据接口泛型确定事件类型

    相关代码

    // 事件解耦例子
@Configuration
public class A48_1 {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(A48_1.class);
        context.getBean(MyService.class).doBusiness();
        context.close();
    }

    static class MyEvent extends ApplicationEvent {
        public MyEvent(Object source) {
            super(source);
        }
    }
    @Component
    static class MyService {
        private static final Logger log = LoggerFactory.getLogger(MyService.class);
        @Autowired
        private ApplicationEventPublisher publisher; // applicationContext 具体主题角色类
        public void doBusiness() {
            log.debug("主线业务");
            // 主线业务完成后需要做一些支线业务，下面是问题代码
            publisher.publishEvent(new MyEvent("MyService.doBusiness()"));
        }
    }

    //具体主题角色类
    @Component
    static class SmsApplicationListener implements ApplicationListener<MyEvent> {
        private static final Logger log = LoggerFactory.getLogger(SmsApplicationListener.class);
        @Override
        public void onApplicationEvent(MyEvent event) {
            log.debug("发送短信");
        }
    }

    @Component
    static class EmailApplicationListener implements ApplicationListener<MyEvent> {
        private static final Logger log = LoggerFactory.getLogger(EmailApplicationListener.class);
        @Override
        public void onApplicationEvent(MyEvent event) {
            log.debug("发送邮件");
        }
    }

}

  • 2、@EventListener 标注监听方法

    • 根据监听器方法参数确定事件类型

    • 解析时机：在 SmartInitializingSingleton（所有单例初始化完成后），解析每个单例 bean

      @Configuration
public class A48_2 {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(A48_2.class);
        context.getBean(MyService.class).doBusiness();
        context.close();
    }

    static class MyEvent extends ApplicationEvent {
        public MyEvent(Object source) {
            super(source);
        }
    }

    @Component
    static class MyService {
        private static final Logger log = LoggerFactory.getLogger(MyService.class);
        @Autowired
        private ApplicationEventPublisher publisher; // applicationContext
        public void doBusiness() {
            log.debug("主线业务");
            // 主线业务完成后需要做一些支线业务，下面是问题代码
            publisher.publishEvent(new MyEvent("MyService.doBusiness()"));
        }
    }
    @Component
    static class SmsService {
        private static final Logger log = LoggerFactory.getLogger(SmsService.class);
        @EventListener
        public void listener(MyEvent myEvent) {
            log.debug("发送短信");
        }
    }

    @Component
    static class EmailService {
        private static final Logger log = LoggerFactory.getLogger(EmailService.class);
        @EventListener
        public void listener(MyEvent myEvent) {
            log.debug("发送邮件");
        }
    }
    //设置多线程
    @Bean
    public ThreadPoolTaskExecutor executor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(3);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(100);
        return executor;
    }

    @Bean
    public SimpleApplicationEventMulticaster applicationEventMulticaster(ThreadPoolTaskExecutor executor) {
        SimpleApplicationEventMulticaster multicaster = new SimpleApplicationEventMulticaster();
        multicaster.setTaskExecutor(executor);
        return multicaster;
    }
}

    可以设置多线程实现异步监听

  • 3、自定义注解实现监听

    package com.example.springevent.a48;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.SmartInitializingSingleton;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationListener;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * @author: liang
 * @DATE: 2023/1/3
 * @PACKAGE_NAME: com.example.springevent.a48
 * @NAME: A48_3
 * @PROJECT_NAME: 自定义注解
 **/
@Configuration
public class A48_3 {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(A48_3.class);
        context.getBean(MyService.class).doBusiness();
        context.close();

    }

    /**
     * * 单例初始化后被调用
     * @param context
     * @return
     */
    @Bean
    public SmartInitializingSingleton smartInitializingSingleton(ConfigurableApplicationContext context){
        return  new SmartInitializingSingleton(){
            @Override
            public void afterSingletonsInstantiated() {
                for (String name : context.getBeanDefinitionNames()) {
                    Object bean = context.getBean(name);
                    //获取方法对象
                    for (Method method : bean.getClass().getMethods()) {
                        //判断方法对象是否存在MyListener注解,适配器模式
                        if (method.isAnnotationPresent(MyListener.class)) {
                            ApplicationListener listener = new ApplicationListener<ApplicationEvent>() {
                                @Override
                                public void onApplicationEvent(ApplicationEvent event) {
                                    System.out.println(event);
                                    //监听器方法需要的事件类型
                                    Class<?> eventType = method.getParameterTypes()[0];
                                    if (eventType.isAssignableFrom(event.getClass())){
                                        try {
                                            method.invoke(bean,event);
                                        } catch (Exception e) {
                                            e.printStackTrace();
                                        }
                                    }
                                };
                            };
                            //将listener加入到监听器中，让context知道
                            context.addApplicationListener(listener);
                        }
                    }
                }
            }
        };

    }

    @Component
    static class MyService {
        private static final Logger log = LoggerFactory.getLogger(MyService.class);
        @Autowired
        private ApplicationEventPublisher publisher; // applicationContext

        public void doBusiness() {
            log.debug("主线业务");
            // 主线业务完成后需要做一些支线业务，下面是问题代码
            publisher.publishEvent(new MyEvent("MyService.doBusiness()"));
        }
    }

    @Component
    static class SmsService {
        private static final Logger log = LoggerFactory.getLogger(SmsService.class);

        @MyListener
        public void listener(MyEvent myEvent) {
            log.debug("发送短信");
        }
    }

    @Component
    static class EmailService {
        private static final Logger log = LoggerFactory.getLogger(EmailService.class);

        @MyListener
        public void listener(MyEvent myEvent) {
            log.debug("发送邮件");
        }
    }
	
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    @interface MyListener {
    }

    static class MyEvent extends ApplicationEvent {
        public MyEvent(Object source) {
            super(source);
        }
    }
}

3.2、事件发布器

事件发布器模拟实现

  1. addApplicationListenerBean 负责收集容器中的监听器
    • 监听器会统一转换为 GenericApplicationListener 对象，以支持判断事件类型
  2. multicastEvent 遍历监听器集合，发布事件
    • 发布前先通过 GenericApplicationListener.supportsEventType 判断支持该事件类型才发事件
    • 可以利用线程池进行异步发事件优化
  3. 如果发送的事件对象不是 ApplicationEvent 类型，Spring 会把它包装为 PayloadApplicationEvent 并用泛型技术解析事件对象的原始类型
    • 视频中未讲解
@Configuration
public class A49 {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(A49.class);
        context.getBean(MyService.class).doBusiness();
        context.close();
    }

    static class MyEvent extends ApplicationEvent {
        public MyEvent(Object source) {
            super(source);
        }
    }

    @Component
    static class MyService {
        private static final Logger log = LoggerFactory.getLogger(MyService.class);
        @Autowired
        private ApplicationEventPublisher publisher; // applicationContext

        public void doBusiness() {
            log.debug("主线业务");
            // 主线业务完成后需要做一些支线业务，下面是问题代码
            publisher.publishEvent(new MyEvent("MyService.doBusiness()"));
        }
    }

    @Component
    static class SmsApplicationListener implements ApplicationListener<MyEvent> {
        private static final Logger log = LoggerFactory.getLogger(SmsApplicationListener.class);

        @Override
        public void onApplicationEvent(MyEvent event) {
            log.debug("发送短信");
        }
    }

    @Component
    static class EmailApplicationListener implements ApplicationListener<MyEvent> {
        private static final Logger log = LoggerFactory.getLogger(EmailApplicationListener.class);
        @Override
        public void onApplicationEvent(MyEvent event) {
            log.debug("发送邮件");
        }
    }

    @Bean
    public ThreadPoolTaskExecutor executor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(3);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(100);
        return executor;
    }
    @Bean
    public ApplicationEventMulticaster applicationEventMulticaster(ConfigurableApplicationContext context, ThreadPoolTaskExecutor executor){
        return new AbstractApplicationEventMulticaster() {
            private List<GenericApplicationListener> listeners = new ArrayList<>();
            //收集监听器
            @Override
            public void addApplicationListenerBean(String name) {
                ApplicationListener listener = context.getBean(name, ApplicationListener.class);
                //获取该监听器支持的事件类型
                ResolvableType type = ResolvableType.forClass(listener.getClass()).getInterfaces()[0].getGeneric();
                System.out.println("type = " + type);

                //将原始的listener封装为支持事件检查的listener
                GenericApplicationListener genericApplicationListener = new GenericApplicationListener() {

                    @Override
                    public void onApplicationEvent(ApplicationEvent event) {
                        listener.onApplicationEvent(event);
                    }
                    //判断是否支持某事件类型
                    @Override
                    public boolean supportsEventType(ResolvableType eventType) {
                        //判断eventType是否能赋值给type
                        return type.isAssignableFrom(eventType);
                    }
                };
                listeners.add(genericApplicationListener);
            }

            //发布事件
            @Override
            public void multicastEvent(ApplicationEvent event, ResolvableType eventType) {
                for (GenericApplicationListener listener : listeners) {
                    if (listener.supportsEventType(ResolvableType.forClass(event.getClass()))) {
                        listener.onApplicationEvent(event);
                    }

                }
            }
        };
    }

    abstract static class AbstractApplicationEventMulticaster implements ApplicationEventMulticaster {
         @Override
         public void addApplicationListener(ApplicationListener<?> listener) {

         }

         @Override
         public void addApplicationListenerBean(String listenerBeanName) {

         }

         @Override
         public void removeApplicationListener(ApplicationListener<?> listener) {

         }

         @Override
         public void removeApplicationListenerBean(String listenerBeanName) {

         }

         @Override
         public void removeApplicationListeners(Predicate<ApplicationListener<?>> predicate) {

         }

         @Override
         public void removeApplicationListenerBeans(Predicate<String> predicate) {

         }

         @Override
         public void removeAllListeners() {

         }

         @Override
         public void multicastEvent(ApplicationEvent event) {

         }

         @Override
         public void multicastEvent(ApplicationEvent event, ResolvableType eventType) {

         }
     }
}
d_xia
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring事件
qq_37705525的博客
05-16 1348
Spring事件
Spring - 事件监听机制 源码解析
热门推荐
小工匠
12-17 2万+
事件事件生产者事件消费者控制器 （管理生产者、消费者和事件之间的注册监听关系）在Spring中，事件监听机制主要实现是通过事件、事件监听器、事件发布者和事件广播器来实现。
Spring事件监听机制
CodAlun的博客
08-19 943
Spring事件监听机制详解
Spring 事件广播机制详解
MarkusZhang的博客
03-28 1086
写这篇文章的初衷源自对 Spring 框架中事件机制的好奇心。在编写观察者模式代码示例时，我突然想起了 Spring 框架中支持多事件监听的特性，例如ContextClosedEvent、ContextRefreshedEvent、ContextStartedEvent等等。传统的观察者模式通常是基于单一事件的，但 Spring 框架却提供了一种更为灵活的机制，可以处理多个不同类型的事件。因此，我决定深入研究 Spring 框架中多事件监听的实现机制，并将我的学习总结记录下来。
Spring事件监听
Shawn的个人博客
07-29 1356
Spring的事件监听机制和发布订阅机制是很相似的发布了一个事件后，监听该类型事件的所有监听器会触发相应的处理逻辑。正如Spring官方文档上所说的，整个上就是一个观察者的模式。那么，我们不妨猜测下，Spring是如何来实现事件发布监听的底层使用一个集合存储了所有的监听器，当发布了一个事件后，遍历事件监听器集合，然后过滤符合事件类型的监听器，最后触发相应的事件处理逻辑。//必须继承实现publicMyEvent(Objectsource,Stringmsg){}}...
Spring 的事件发布机制
JavaJasper的博客
02-04 1585
Spring 事件发布机制详解
spring事件监听与发布
RT_0114的博客
09-08 739
在使用 Spring构建的应用程序中，适当使用事件发布与监听的机制可以使我们的代码灵活度更高，降低耦合度。Spring提供了完整的事件发布与监听模型，在该模型中，事件发布方只需将事件发布出去，无需关心有多少个对应的事件监听器；监听器无需关心是谁发布了事件，并且可以同时监听来自多个事件发布方发布的事件，通过这种机制，事件发布与监听是解耦的。创建/监听事件应该以下准则事件类应该继承事件的发布者应该注入事件监听者应该实现创建事件类 继承} }创建事件的发布者 注入。
Spring 事件发布
暮色妖娆丶
08-11 956
前言 事件发布是 Spring 框架中最容易被忽视的功能之一，但实际上它是一个很有用的功能。使用事件机制可以将同一个应用系统内互相耦合的代码进行解耦，并且可以将事件与 Spring 事务结合起来，实现我们工作中的一些业务需求。和 Spring 的事务类似，Spring 事务有编程式事务、声明式事务，Spring 事件也分为编程式事件和声明式事件，本篇主要讲解使用注解实现声明式事件发布和监听。 Spring 内置事件 对 Spring 有点了解的话应该不陌生 Spring 的内置事件，从官网可知 Spring
Spring事件监听Listener
java123456111的博客
05-11 2313
1、Spring事件原理 原理：观察者模式 spring的事件监听有三部分组成： 1）事件（ApplicationEvent）负责对应相应监听器 事件源发生某事件是特定事件监听器被触发的原因。 2）事件发布器（ApplicationEventMulticaster）对应于观察者模式中的被观察者/主题， 负责通知观察者（监听器） 对外提供发布事件和增删事件监听器的接口,维护事件和事件监听器之间的映射关系,并在事件发生时负责通知相关监听器。 3）监听器（ApplicationListener）对应于观察者模式中
Spring事件发布与监听机制
陈皮的JavaLib
06-27 1288
我是陈皮，一个在互联网 Coding 的 ITer，微信搜索「陈皮的JavaLib」第一时间阅读最新文章，回复【资料】，即可获得我精心整理的技术资料，电子书籍，一线大厂面试资料和优秀简历模板。 文章目录前言ApplicationContext 事件机制ApplicationListener 监听器ApplicationEvent 事件自定义事件和监听器注解式监听器 前言 Spring 提供了 ApplicationContext 事件机制，可以发布和监听事件，这个特性非常有用。 Spring 内置了一.
Spring事件管理
01-25
接下来，我们将深入探讨Spring事件管理的核心概念和实现方式。 首先，Spring事件是基于Java的观察者模式（Observer Pattern）实现的，它定义了主题（Subject）和观察者（Observer）之间的关系，当主题的状态发生...
Spring事件Application Event原理详解
08-25
1. 事件创建：创建一个事件对象，例如 DemoEvent。 2. 事件发布：使用 ApplicationContext 的 publishEvent 方法来发布事件。 3. 事件监听：事件监听器接收到事件，并在 onApplicationEvent 方法中处理事件。 4. ...
spring 事件处理
04-18
Spring事件处理基于发布/订阅模式，其中事件是消息的载体，而事件监听器则是对这些消息感兴趣的订阅者。在这个场景中，我们将探讨Spring MVC实例与Spring事件处理的结合。 首先，让我们了解Spring MVC。Spring MVC...
第十七章 Spring 事件（Events）1
08-03
本章将深入探讨Spring事件（Events）的相关知识点。 首先，Java事件/监听器编程模型是基于观察者模式的，该模式定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并被...
spring扩展原理1
08-08
将监听器加入到容器后，只要容器中有相关事件发布，监听器就能捕获到这些事件并执行回调方法。通过`applicationContext.publishEvent()`可以主动发布自定义事件，进一步增强了Spring应用的响应性和交互性。 在事件...
5.SpringBoot核心源码-启动类源码分析
最新发布
流月up的博客
07-12 337
SpringBoot核心源码-启动类源码分析
elk部署springboot
Chihirozy的博客
07-11 297
elk部署springboot。
基于SpringBoot+Hadoop+python的物品租赁系统(带1w+文档)
神聪程序
07-10 799
物品租赁系统是电子、信息技术相结合，是一种必然的发展趋势。以互联网为基础，以服务于广大用户为目的，发展整体优势，扩大规模，提升服务质量，提高物品租赁的管理效率。物品租赁系统实现了物品租赁管理向现代化和网络化的转型，为管理决策和控制提供保障，这是物品租赁管理发展中里程碑式的转型。
基于SpringBoot构造超简易QQ邮件服务发送 第二版
键盘爱好者
07-09 262
第二版的更新点是追加了 邮箱附件功能 ( 后期追加定时任务 )

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值