Spring手撸源码系列-容器事件和事件监听器

最新推荐文章于 2023-09-10 19:11:44 发布
最新推荐文章于 2023-09-10 19:11:44 发布
阅读量304 收藏
点赞数
分类专栏： # spring 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dfBeautifulLive/article/details/124752380
版权

Spring中有个event事件，可以提供事件的定义、监听和发布事件操作，此次事件监听发布的实现采用的是观察者模式，这种一个地方发布了事件，需要另一个地方立刻监听感知到比较适合观察者模式，实现完毕，我们自定义实现的事件可以在spring生命周期里进行定义，监听发布。

在此种实现中，需要设计出事件定义，对事件的监听，以及对事件的发布，对事件的发布需要广播器进行处理等等，程序的入口，需要用到之前都一直在用的上下文刷新类AbstractApplicationContext的refresh()，用它初始化事件广播器，并发布一些刷新事件和关闭容器等事件，接下来咱们开始把

1.工程目录

├─src
│  ├─main
│  │  ├─java
│  │  │  └─com
│  │  │      └─spring
│  │  │          └─sourcecode
│  │  │              │  SourcecodeApplication.java
│  │  │              │  
│  │  │              └─springframework
│  │  │                  │  BeanDefinition.java
│  │  │                  │  BeanFactory.java
│  │  │                  │  
│  │  │                  ├─beans
│  │  │                  │  │  BeansException.java
│  │  │                  │  │  PropertyValue.java
│  │  │                  │  │  PropertyValues.java
│  │  │                  │  │  
│  │  │                  │  └─factory
│  │  │                  │      │  Aware.java
│  │  │                  │      │  BeanClassLoaderAware.java
│  │  │                  │      │  BeanFactory.java
│  │  │                  │      │  BeanFactoryAware.java
│  │  │                  │      │  BeanNameAware.java
│  │  │                  │      │  ConfigurableListableBeanFactory.java
│  │  │                  │      │  DisposableBean.java
│  │  │                  │      │  FactoryBean.java
│  │  │                  │      │  HierarchicalBeanFactory.java
│  │  │                  │      │  InitializingBean.java
│  │  │                  │      │  ListableBeanFactory.java
│  │  │                  │      │  
│  │  │                  │      ├─config
│  │  │                  │      │      AutowireCapableBeanFactory.java
│  │  │                  │      │      BeanDefinition.java
│  │  │                  │      │      BeanFactoryPostProcessor.java
│  │  │                  │      │      BeanPostProcessor.java
│  │  │                  │      │      BeanReference.java
│  │  │                  │      │      ConfigurableBeanFactory.java
│  │  │                  │      │      SingletonBeanRegistry.java
│  │  │                  │      │      
│  │  │                  │      ├─support
│  │  │                  │      │      AbstractAutowireCapableBeanFactory.java
│  │  │                  │      │      AbstractBeanDefinitionReader.java
│  │  │                  │      │      AbstractBeanFactory.java
│  │  │                  │      │      BeanDefinitionReader.java
│  │  │                  │      │      BeanDefinitionRegistry.java
│  │  │                  │      │      CglibSubclassingInstantiationStrategy.java
│  │  │                  │      │      DefaultListableBeanFactory.java
│  │  │                  │      │      DefaultSingletonBeanRegistry.java
│  │  │                  │      │      DisposableBeanAdapter.java
│  │  │                  │      │      FactoryBeanRegistrySupport.java
│  │  │                  │      │      InstantiationStrategy.java
│  │  │                  │      │      SimpleInstantiationStrategy.java
│  │  │                  │      │      
│  │  │                  │      └─xml
│  │  │                  │              XmlBeanDefinitionReader.java
│  │  │                  │              
│  │  │                  ├─context
│  │  │                  │  │  ApplicationContext.java
│  │  │                  │  │  ApplicationContextAware.java
│  │  │                  │  │  ApplicationEvent.java
│  │  │                  │  │  ApplicationEventPublisher.java
│  │  │                  │  │  ApplicationListener.java
│  │  │                  │  │  ConfigurableApplicationContext.java
│  │  │                  │  │  
│  │  │                  │  ├─event
│  │  │                  │  │      AbstractApplicationEventMulticaster.java
│  │  │                  │  │      ApplicationContextEvent.java
│  │  │                  │  │      ApplicationEventMulticaster.java
│  │  │                  │  │      ContextClosedEvent.java
│  │  │                  │  │      ContextRefreshedEvent.java
│  │  │                  │  │      SimpleApplicationEventMulticaster.java
│  │  │                  │  │      
│  │  │                  │  └─supprot
│  │  │                  │          AbstractApplicationContext.java
│  │  │                  │          AbstractRefreshableApplicationContext.java
│  │  │                  │          AbstractXmlApplicationContext.java
│  │  │                  │          ApplicationContextAwareProcessor.java
│  │  │                  │          ClassPathXmlApplicationContext.java
│  │  │                  │          
│  │  │                  ├─core
│  │  │                  │  └─io
│  │  │                  │          ClassPathResource.java
│  │  │                  │          DefaultResourceLoader.java
│  │  │                  │          FileSystemResource.java
│  │  │                  │          Resource.java
│  │  │                  │          ResourceLoader.java
│  │  │                  │          UrlResource.java
│  │  │                  │          
│  │  │                  └─util
│  │  │                          ClassUtils.java
│  │  │                          
│  │  └─resources
│  │          application.properties
│  │          spring.xml
│  │          
│  └─test
│      └─java
│          └─com
│              └─spring
│                  └─sourcecode
│                      │  SourcecodeApplicationTests.java
│                      │  
│                      └─springframework
│                          │  ApiTest.java
│                          │  
│                          └─test
│                              └─event
│                                      ContextClosedEventListener.java
│                                      ContextRefreshedEventListener.java
│                                      CustomEvent.java
│                                      CustomEventListener.java
│

2.xml类图

1.ApplicationEvent

所有事件定义的父类，对于ContextRefreshedEvent来说就是刷新事件，对于ContextClosedEvent来说就是关闭事件的定义，就是用来对事件的定义

2.ApplicationListener事件监听器

ApplicationListener是个接口，当你想要实现刷新容器时进行监听可定义刷新监听器在进行实现ApplicationListener此接口，可用来自定义监听

3.ApplicationEventMulticaster

此接口是事件广播器，主要定义几个功能，用来注册事件监听器到容器里，从容器里删除监听器， 将给定的事件多播到对应发布出去

4.ApplicationEventPublisher

事件发布的定义接口，实现类里主要是用广播器发布出去

3.代码实现

 ApplicationEvent类，继承EventObject，主要是jdk自带的事件的父类

package com.spring.sourcecode.springframework.context;

import java.util.EventObject;

/**
 * @Author df
 * @Date 2022/5/8 18:55
 * @Version 1.0
 *
 * 抽象应用事件类
 */
public abstract class ApplicationEvent extends EventObject {

    /**
     * Constructs a prototypical Event.
     *
     * @param source The object on which the Event initially occurred.
     * @throws IllegalArgumentException if source is null.
     */
    public ApplicationEvent(Object source) {
        // 调用父类的构造方法
        super(source);
    }
}

ApplicationContextEvent

package com.spring.sourcecode.springframework.context.event;

import com.spring.sourcecode.springframework.context.ApplicationContext;
import com.spring.sourcecode.springframework.context.ApplicationEvent;

/**
 * @Author df
 * @Date 2022/5/8 19:00
 * @Version 1.0
 *
 */
public class ApplicationContextEvent extends ApplicationEvent {
    /**
     * Constructs a prototypical Event.
     *
     * @param source The object on which the Event initially occurred.
     * @throws IllegalArgumentException if source is null.
     */
    public ApplicationContextEvent(Object source) {
        super(source);
    }

    /*public final ApplicationContext getApplicationContext() {
        return (ApplicationContext) getSource();
    }*/


}

ContextClosedEvent

package com.spring.sourcecode.springframework.context.event;

/**
 * @Author df
 * @Date 2022/5/8 20:11
 * @Version 1.0
 * // 具体的事件定义
 */
public class ContextClosedEvent extends ApplicationContextEvent {
    /**
     * Constructs a prototypical Event.
     *
     * @param source The object on which the Event initially occurred.
     * @throws IllegalArgumentException if source is null.
     */
    public ContextClosedEvent(Object source) {
        super(source);
    }
}

ContextRefreshedEvent

package com.spring.sourcecode.springframework.context.event;

/**
 * @Author df
 * @Date 2022/5/8 20:12
 * @Version 1.0
 */
public class ContextRefreshedEvent extends ApplicationContextEvent {
    /**
     * Constructs a prototypical Event.
     *
     * @param source The object on which the Event initially occurred.
     * @throws IllegalArgumentException if source is null.
     */
    public ContextRefreshedEvent(Object source) {
        super(source);
    }
}

ApplicationEventMulticaster：定义事件广播器

package com.spring.sourcecode.springframework.context.event;

import com.spring.sourcecode.springframework.context.ApplicationEvent;
import com.spring.sourcecode.springframework.context.ApplicationListener;

/**
 * @Author df
 * @Date 2022/5/8 20:54
 * @Version 1.0
 */

// 事件广播器
public interface ApplicationEventMulticaster {
    // 添加要通知所有事件的监听器
    void addApplicationListener(ApplicationListener<?> listener);
    // 从通知列表中删除监听器
    void removeApplicationListener(ApplicationListener<?> listener);
    // 将给定的应用程序事件多播到适当的监听器
    void multicastEvent(ApplicationEvent applicationEvent);
}

AbstractApplicationEventMulticaster：定义抽象类实现ApplicationEventMulticaster类的部分实现，如addApplicationListener和removeApplicationListener。此类中还定义了getApplicationListeners()，主要是获取容器中所有的监听器是否符合你给定的监听事件，符合的进行返回，并调用对应的监听实现。

package com.spring.sourcecode.springframework.context.event;

import com.spring.sourcecode.springframework.beans.BeansException;
import com.spring.sourcecode.springframework.beans.factory.BeanFactory;
import com.spring.sourcecode.springframework.beans.factory.BeanFactoryAware;
import com.spring.sourcecode.springframework.context.ApplicationEvent;
import com.spring.sourcecode.springframework.context.ApplicationListener;
import org.springframework.util.ClassUtils;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Collection;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.Set;

/**
 * @Author df
 * @Date 2022/5/13 10:38
 * @Version 1.0
 */
public abstract class AbstractApplicationEventMulticaster implements ApplicationEventMulticaster {

    private final Set<ApplicationListener<ApplicationEvent>> applicationListeners = new LinkedHashSet<>();


   /* @Override
    public void setBeanFactory(BeanFactory beanFactory) {
        this.beanFactory = beanFactory;
    }*/

    @Override
    public void addApplicationListener(ApplicationListener<?> listener) {
        applicationListeners.add((ApplicationListener<ApplicationEvent>) listener);
    }

    @Override
    public void removeApplicationListener(ApplicationListener<?> listener) {
        applicationListeners.remove(listener);
    }



    // 摘取符合广播事件中的监听处理器，具体过滤动作在supportsEvent中
    // 1.将所有的和ApplicationListener类有关系的都存储到应用事件容器里
    // 2.比如在bean处理时刷新到容器中完成时，则刷新事件并发布刷新事件
    // 3.这时将传过来的刷新事件与之前存储容器事件进行对比
    // 4.对比成功以后就存储到list以后返回
    // 循环容器中存储的监听事件和你要发布的事件是否一致
    protected Collection<ApplicationListener> getApplicationListeners(ApplicationEvent event) {
        LinkedList<ApplicationListener> allListeners = new LinkedList<ApplicationListener>();
        for (ApplicationListener<ApplicationEvent> listener : applicationListeners) {
            if (supportsEvent(listener, event)) allListeners.add(listener);
        }
        return allListeners;
    }

    /**
     * 监听器是否对该事件感兴趣
     */
    protected boolean supportsEvent(ApplicationListener<ApplicationEvent> applicationListener, ApplicationEvent event) {
        Class<? extends ApplicationListener> listenerClass = applicationListener.getClass();

        // 按照 CglibSubclassingInstantiationStrategy、SimpleInstantiationStrategy 不同的实例化类型，需要判断后获取目标 class
        Class<?> targetClass = ClassUtils.isCglibProxyClass(listenerClass) ? listenerClass.getSuperclass() : listenerClass;
        Type genericInterface = targetClass.getGenericInterfaces()[0];

        Type actualTypeArgument = ((ParameterizedType) genericInterface).getActualTypeArguments()[0];
        String className = actualTypeArgument.getTypeName();
        Class<?> eventClassName;
        try {
            eventClassName = Class.forName(className);
        } catch (ClassNotFoundException e) {
            throw new BeansException("wrong event class name: " + className);
        }
        // 判定此 eventClassName 对象所表示的类或接口与指定的 event.getClass() 参数所表示的类或接口是否相同，或是否是其超类或超接口。
        // isAssignableFrom是用来判断子类和父类的关系的，或者接口的实现类和接口的关系的，默认所有的类的终极父类都是Object。如果A.isAssignableFrom(B)结果是true，证明B可以转换成为A,也就是A可以由B转换而来。
        return eventClassName.isAssignableFrom(event.getClass());
    }
    
}

SimpleApplicationEventMulticaster：此类继承AbstractApplicationEventMulticaster广播器，当是匹配的监听器，实现发布广播。

package com.spring.sourcecode.springframework.context.event;

import com.spring.sourcecode.springframework.beans.factory.BeanFactory;
import com.spring.sourcecode.springframework.context.ApplicationEvent;
import com.spring.sourcecode.springframework.context.ApplicationListener;

/**
 * @Author df
 * @Date 2022/5/13 10:58
 * @Version 1.0
 */
public class SimpleApplicationEventMulticaster extends AbstractApplicationEventMulticaster {

    // 调用实现的事件处理器
    @Override
    public void multicastEvent(final ApplicationEvent applicationEvent) {
        for (final ApplicationListener listener : getApplicationListeners(applicationEvent)) {
            listener.onApplicationEvent(applicationEvent);
        }
    }
}

ApplicationEventPublisher：事件发布定义

/**
 * @Author df
 * @Date 2022/5/13 10:46
 * @Version 1.0
 * // 事件发布者定义
 */
public interface ApplicationEventPublisher {
    void publishEvent(ApplicationEvent event);
}

AbstractApplicationContext部分实现，只添加本节添加的东西，添加了初始化广播器

以及注册事件监听器，发布刷新容器，和关闭容器

  @Override
    public void refresh() {

        // 6.
        initApplicationEventMulticaster();

        // 7.注册事件监听器
        registerListeners();

        // 8.提前实例化单例bean对象
        // 通过beanDefinationMap里的实例对象将后续bean实例进行实例化，并处理后置修改的对象
        beanFactory.preInstantiateSingletons();

        // 9. 发布容器刷新完成事件
        finishRefresh();

    }

 private void initApplicationEventMulticaster() {
        //ConfigurableListableBeanFactory beanFactory = getBeanFactory();
        applicationEventMulticaster = new SimpleApplicationEventMulticaster();
        //beanFactory
    }

    // 将配置文件的关于监听的配置进行注册存储容器里
    private void registerListeners() {
        Collection<ApplicationListener> applicationListeners = getBeansOfType(ApplicationListener.class).values();
        for (ApplicationListener listener : applicationListeners) {
            applicationEventMulticaster.addApplicationListener(listener);
        }
    }

    private void finishRefresh() {
        publishEvent(new ContextRefreshedEvent(this));
    }

    @Override
    public void publishEvent(ApplicationEvent event) {
        applicationEventMulticaster.multicastEvent(event);
    }


  @Override
    public void close() {
        // 发布容器关闭事件
        publishEvent(new ContextClosedEvent(this));

        getBeanFactory().destroySingletons();
    }

4.测试准备

4.1 创建一个自定义事件和监听器

package com.spring.sourcecode.springframework.test.event;

import com.spring.sourcecode.springframework.context.event.ApplicationContextEvent;

/**
 * @Author df
 * @Date 2022/5/13 11:24
 * @Version 1.0
 */
public class CustomEvent extends ApplicationContextEvent {
    private Long id;
    private String message;

    /**
     * Constructs a prototypical Event.
     *
     * @param source The object on which the Event initially occurred.
     * @throws IllegalArgumentException if source is null.
     */
    public CustomEvent(Object source, Long id, String message) {
        super(source);
        this.id = id;
        this.message = message;
    }

   // 省略set/get
}

自定义事件监听器

package com.spring.sourcecode.springframework.test.event;

import com.spring.sourcecode.springframework.context.ApplicationListener;

import java.util.Date;

/**
 * @Author df
 * @Date 2022/5/13 11:27
 * @Version 1.0
 */
public class CustomEventListener implements ApplicationListener<CustomEvent> {
    @Override
    public void onApplicationEvent(CustomEvent event) {
        System.out.println("收到：" + event.getSource() + "消息;时间：" + new Date());
        System.out.println("消息：" + event.getId() + ":" + event.getMessage());
    }
}

4.2 创建一个容器刷新事件监听器

package com.spring.sourcecode.springframework.test.event;

import com.spring.sourcecode.springframework.context.ApplicationListener;
import com.spring.sourcecode.springframework.context.event.ContextRefreshedEvent;

/**
 * @Author df
 * @Date 2022/5/13 11:52
 * @Version 1.0
 */
public class ContextRefreshedEventListener implements ApplicationListener<ContextRefreshedEvent> {
    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        System.out.println("刷新事件");
    }
}

4.3 创建一个事件关闭监听处理器

package com.spring.sourcecode.springframework.test.event;

import com.spring.sourcecode.springframework.context.ApplicationListener;
import com.spring.sourcecode.springframework.context.event.ContextRefreshedEvent;

/**
 * @Author df
 * @Date 2022/5/13 11:52
 * @Version 1.0
 */
public class ContextRefreshedEventListener implements ApplicationListener<ContextRefreshedEvent> {
    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        System.out.println("刷新事件");
    }
}

4.4 配置文件，将几个监听器配置进来

<?xml version="1.0" encoding="UTF-8" ?>
<beans>
    <bean class="com.spring.sourcecode.springframework.test.event.CustomEventListener">
    </bean>

    <bean class="com.spring.sourcecode.springframework.test.event.ContextClosedEventListener">
    </bean>

    <bean class="com.spring.sourcecode.springframework.test.event.ContextRefreshedEventListener">
    </bean>
</beans>

4.5 单元测试

public class ApiTest {
    //
    @Test
    public void testFactoryBean() {
        // 1.初始化BeanFactory
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:spring.xml");
        applicationContext.publishEvent(new CustomEvent(applicationContext, 1019129009086763L, "成功了！"));
        applicationContext.registerShutdownHook();
    }
}

5.测试结果

 

PromisingGirl-Du
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java事件机制
iteye_12502的博客
10-13 131
事件源负责产生事件 事件类：定义事件的特征； 监听器接口：定义监听器应该实现的功能； 监听器：实现监听器接口，监听事件的发生并作出响应； 所有的事件类必须继承Java事件基类，即java.util.EventObject；EventObject(Object source)是EventObject唯一的构造方法，这意味着所有事件必须在实例化时就指定事件源；EventObject类提供了g...
Spring进阶（二十）之事件处理
weixin_56644618的博客
12-02 819
对于进阶spring，学习事件处理是必不可少的
Spring 事件源的用途
fenglllle的博客
11-01 635
前言 Spring已经非常熟悉，Spring容器状态事件也是日常使用的功能，经常用于解耦，但是有时候事件却会重复的监听，此时就需要处理了，source也是有特殊用途的。 1. demo 构造一个Spring boot应用，写一个监听器。 @SpringBootApplication public class EventMain { public static void main(String[] args) { ConfigurableApplicationContext
spring 中的事件
qq_38807606的博客
06-08 920
1. 应用启动的时候，初始化 事件广播器，事件广播器 调用 容器里的 监听器，调用对应的目标方法 弄清楚Java 中的事件原理，无非要弄清楚三个角色：事件源（source）、事件对象（EventObject）、事件监听器（EventListener）。 注：Java 中的java.util 包中的EventObject 与EventListener 是所有事件对象与监听器的最基础的类。 流程：事件源 发布 事件 ，然后 事件源获取时间广播器 ，通过事件广播器 调用 事..
Spring中的事件处理机制
qq_42372935的博客
11-09 1000
Spring中的事件处理机制
spring boot源码
05-10
3. 在容器创建前，通过监听器机制，应对不同阶段加载数据、更新数据的需求 4. 容器初始化过程中追加各种功能，例如统计时间、输出日志等 监听器类型 1. 在应用运行但未进行任何处理时，将发送 ...
spring-boot-study：SpringBoot框架源码实战（已更新到springboot2版本实现）〜基本用法，Rest，Controller，事件监听，连接数据库MySQL，jpa，redis集成，mybatis集成（声明式与xml两种方式〜对应的添删查改功能），日志处理，devtools配置，拦截器用法，资源配置读取，测试集成，网络层实现请求映射，安全安全验证，rabbitMq集成，kafka集成，分布式id生成器等。实战：https：github.comhemin1003yfax-pare
01-29
新增全新的springboot2的框架技术点（代码位于当前仓库的spring-boot2-study目录下） 基于springboot 2.0.6.RELEASE版本实现的代码演示集合，欢迎使用star / fork 新子项目列表 介绍Springboot2【自动化单元测试】的...
Spring-Reference_zh_CN（Spring中文参考手册）
06-06
3.2. 容器和bean的基本原理 3.2.1. 容器 3.2.1.1. 配置元数据 3.2.2. 实例化容器 3.2.2.1. 组成基于XML配置元数据 3.2.3. 多种bean 3.2.3.1. 命名bean 3.2.3.2. 实例化bean 3.2.4. 使用容器 3.3. 依赖 3.3.1. 注入...
java版飞机大战源码-Rockira.github.io:Rockira.github.io
06-04
:microscope:监听器和过滤器 :ring:数据库 MySQL 索引、锁机制 事务特性、隔离级别 MySQL调优与最佳实践 :t-shirt:JDBC :ribbon:AJAX :cooked_rice:JavaWeb小项目 :hamburger:Hibernate :page_facing_up:Struts2 :...
JAVA上百实例源码以及开源项目
01-03
　Java绘制图片火焰效果，源代码相关注释：前景和背景Image对象、Applet和绘制火焰的效果的Image对象、Applet和绘制火焰的效果的Graphics对象、火焰效果的线程、Applet的高度,图片到图片装载器、绘制火焰效果的X坐标...
【Spring | 事件监听详解】
爱媳妇儿爱编程
06-30 3776
Spring 事件监听详解
手写Spring（10）：容器事件和事件监听器
weixin_43354138的博客
03-19 103
这个类中定义了所有监听器的Set集合、add、remove方法，以及getApplicationListeners方法，就是根据指定的事件找到对应的所有监听器，所有的Listener都会将自己指定的事件作为范型参数进行传递，在supportsEvents中会通过反射获取到这个参数来判断set集合中的监听器是否符合要求，最后将所有符合要求的监听器进行返回。需要手动在spring生命周期中的适当位置进行埋点，如refresh( )函数中的finishRefresh( )方法就是在进行埋点。
Spring 事件原理及其应用
JavaShark的博客
07-11 214
在 JDK 中已经提供相应的自定义事件发布功能的基础类:首先了解几个概念：事件类也就是定义发送的内容，比如可以通过继承 来自定义一个特定事件类。1.1 类首先是继承 的 ，通过source来指定事件源： public abstract class ApplicationEvent extends EventObject { /** * Constructs a prototypical Event. * * @param source The object on
Spring 5个标准事件及自定义事件
cristianoxm的博客
05-31 2707
一、spring5个标准事件如下 作用如下： 上下文更新事件（ContextRefreshedEvent）：该事件会在ApplicationContext被初始化或者更新时发布。也可以在调用ConfigurableApplicationContext 接口中的refresh()方法时被触发。 上下文开始事件（ContextStartedEvent）：当容器调用ConfigurableApplicationContext的Start()方法开始/重新开始容器时触发该事件。 上下文停止事件（Conte
怎么监听spring bean 销毁
weixin_42596246的博客
02-15 263
要监听Spring Bean销毁，可以通过实现DisposableBean接口或使用@PreDestroy注解来完成。 DisposableBean接口中有一个destroy()方法，可以在Bean销毁时调用。您可以在自己的Bean类中实现该接口，并在destroy()方法中编写您需要执行的清理代码。 另一种方法是在Bean方法上使用@PreDestroy注解。在Bean销毁时，Spring容器会...
[源码系列：手写spring] IOC第十四节：容器事件和事件监听器
最新发布
一辉的博客
09-10 1155
现实中的观察者(Observer)往往是主动方，这是由于目标主题(Subject)缺乏主观能动性造成的，其状态的更新并不能主动地通知观察者，这就造成观察行为的持续往复。而在软件设计中我们可以将目标主题作为主动方角色，将观察者反转为被动方角色，建立反向驱动式的消息响应机制，以此来避免做无用功，优化软件效率，请参看观察者模式的类结构，如图所示。
Spring系列-5 事件机制
Sheng_Q的博客
12-11 803
本文介绍Spring的事件机制，包括使用方式、注意事项以及实现原理，重心在于介绍事件机制的实现原理。
Spring 容器事件
huhahuha_的博客
10-13 547
ApplicationContext 扩展了 ApplicationEventPublisher 接口. 让容器拥有了发布应用文上下事件的能力.  包括容器启动事件,  关闭事件的功能. 先解释几个名词:  (1)事件源:  事件的产生者.  任何一个 EventObject 都必须拥有一个事件源. (2)事件监听器注册表:  组件或框架的时间监听器必须有所依存. 必须提供一个地方保存时间监...
手写简版spring --10--容器事件和事件监听器
cristianoxm的博客
08-16 262
一、降低耦合 解耦场景在互联网开发的设计中使用的也是非常频繁，如：这里需要一个注册完成事件推送消息、用户下单我会发送一个MQ、收到我的支付消息就可以发货了等等，都是依靠事件订阅和发布以及MQ消息这样的组件，来处理系统之间的调用解耦，最终通过解耦的方式来提升整体系统架构的负载能力。其实解耦思路可以理解为设计模式中观察者模式的具体使用效果，在观察者模式中当对象间存在一对多关系时，则使用观察者模式，它是一种定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。事件
<!--配置Spring的监听器-->
04-30
在使用Spring框架时，我们需要在web.xml配置文件中配置Spring的监听器，以便在应用启动时自动加载Spring配置文件，完成Spring框架的初始化工作。 具体配置方法如下： 1. 在web.xml文件中添加如下代码： ``` ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值