SpringBoot启动扩展点今天具体聊一下SpringBoot的扩展点，SpringBoot框架也是对Spring框架

站长

2024年09月06日 13:17 · 阅读数 22

SpringBoot启动扩展点

:baby_chick: 背景

Spring作为一种编程框架造福着众多Java工程师，其核心理念：依赖注入（DI）, 面向切面（AOP）到SpringBoot的约定大于配置, 均从框架层面来减少工程师的负担。其实任何一种框架其核心无外乎是两种基本模块的组合-容器和计算。容器装载了需要计算的对象和计算过后的对象，而计算则是针对框架需要完成的某些功能进行的逻辑编排。

今天具体聊一下SpringBoot的扩展点，SpringBoot框架也是对Spring框架的封装，其中自动装配的机制方便了很多第三方SDK，中间件，公共依赖工具，三方Jar包的集成。这种机制让使用者以最小的代价接入。想要彻底掌握自动装配，就必须要了解spring对于bean的构造生命周期以及各个扩展接口。当然了解了bean的各个生命周期也能促进我们加深对spring的理解。业务代码也能合理利用这些扩展点写出更加漂亮的代码。

:octopus:可扩展的接口调用顺序

以下是spring容器中Bean的生命周期内所有可扩展的点的调用顺序，左侧表示具体的类，右侧表示可以扩展或者可以从该方法中扩展的相应方法。

SpringBoot启动扩展点今天具体聊一下SpringBoot的扩展点，SpringBoot框架也是对Spring框架

图片来源于: 铂赛东的《Springboot启动扩展点超详细总结，再也不怕面试官问了》博客

:tada: 扩展接口详细介绍

ApplicationContextInitializer

:open_book: 基本介绍

ApplicationContextInitializer 是 Spring 框架中一个接口，它允许开发者在 Spring 应用上下文（ApplicationContext）完全初始化之前对其进行自定义设置或配置。这个接口提供了一个扩展点，使得你可以在 Spring 容器刷新（刷新阶段是 refresh() 方法调用时）之前介入并执行一些初始化逻辑。

org.springframework.context.ApplicationContextInitializer

这是整个spring容器在刷新之前初始化ConfigurableApplicationContext的回调接口，简单来说，就是在容器刷新之前调用此类的initialize方法。这个点允许被用户自己扩展。用户可以在整个spring容器还没被初始化之前做一些事情。

可以想到的场景可能为，在最开始激活一些配置，或者利用这时候class还没被类加载器加载的时机，进行动态字节码注入等操作。

:old_key: 扩展方式

扩展的具体方式：

:leaves: 扩展类TestApplicationContextInitializer

public class TestApplicationContextInitializer implements ApplicationContextInitializer {
    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        System.out.println(" XiaoSheng ApplicationContextInitializer");
    }
}

:mailbox: 生效方式

在spring容器还没被初始化，所以想要自己的扩展的生效，有以下三种方式：

在启动类中用springApplication.addInitializers(new TestApplicationContextInitializer())

/**
 * @author XiaoSheng
 * @date 2024/8/18 下午2:31
 */
@SpringBootApplication
public class Main {

    public static void main(String[] args) {
        SpringApplication springApplication = new SpringApplication();
        springApplication.addInitializers(new TestApplicationContextInitializer());
        springApplication.addPrimarySources(Collections.singleton(Main.class));
        ConfigurableApplicationContext run = springApplication.run(args);
    }
}

配置文件配置context.initializer.classes=xxx.TestApplicationContextInitializer

例如: 我的项目中该文件的路径为: cn.org.xiaosheng.applicationContext.TestApplicationContextInitializer

在项目的``application.yml`中添加如下配置

context:
  initializer:
    classes: cn.org.xiaosheng.applicationContext.TestApplicationContextInitializer

Spring SPI扩展，在spring.factories中加入org.springframework.context.ApplicationContextInitializer=cn.org.xiaosheng.applicationContext.TestApplicationContextInitializerr

SpringBoot启动扩展点今天具体聊一下SpringBoot的扩展点，SpringBoot框架也是对Spring框架

org.springframework.context.ApplicationContextInitializer=cn.org.xiaosheng.applicationContext.TestApplicationContextInitializer

:man_playing_handball: 使用场景

当需要在 Spring 容器启动时执行一些特定的初始化逻辑，而这些逻辑不能通过配置文件或注解来实现时。
当需要对 Spring 容器进行深层次的自定义配置，比如修改容器的某些内部行为。

通过使用 ApplicationContextInitializer，你可以在 Spring 应用的生命周期早期介入，进行一些必要的初始化工作，这为 Spring 应用的自定义和扩展提供了强大的灵活性。

BeanDefinitionRegistryPostProcessor

org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor

:open_book: 基本介绍

BeanDefinitionRegistryPostProcessor 是 Spring 框架中的一个接口，它允许开发者在 Spring 容器的 BeanDefinition 加载完成后，实例化 Bean 之前对其进行修改或扩展。这个接口提供了两个主要的方法，允许你在 Spring 容器的刷新过程中的不同阶段介入：

postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) 方法：
- 这个方法在 BeanDefinition 加载完成后，Bean 实例化之前调用。
- 它接收一个 BeanDefinitionRegistry 对象作为参数，该对象允许你注册新的 BeanDefinition、修改现有 BeanDefinition、移除 BeanDefinition 等。
postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) 方法：
- 这个方法在 BeanFactory 标准初始化之后调用，允许你在 Bean 实例化之前对 BeanFactory 进行修改。
- 它接收一个 ConfigurableListableBeanFactory 对象作为参数，这个对象提供了对 BeanFactory 的配置和操作能力。

:old_key: 扩展方式

实现BeanDefinitionRegistryPostProcessor并重写postProcessBeanDefinitionRegistry和postProcessBeanFactory方法

@Configuration
public class TestBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
        System.out.println("[BeanDefinitionRegistryPostProcessor] postProcessBeanDefinitionRegistry");
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        System.out.println("[BeanDefinitionRegistryPostProcessor] postProcessBeanFactory");
    }
}

:mailbox: 生效方式

使用@Configuration注解将该配置类添加到Spring容器中即可。

:man_playing_handball: 使用场景

当需要对 BeanDefinition 进行动态修改，或者在 Bean 实例化之前需要进行一些特定的处理时，BeanDefinitionRegistryPostProcessor 是一个非常有用的扩展点。

通过使用 BeanDefinitionRegistryPostProcessor，你可以在 Spring 容器的初始化过程中对 BeanDefinition 进行精细控制，实现高度自定义的 Bean 管理策略。这为复杂的应用场景提供了强大的灵活性和扩展性。

BeanFactoryPostProcessor

org.springframework.beans.factory.config.BeanFactoryPostProcessor

:open_book: 基本介绍

BeanFactoryPostProcessor 是 Spring 框架中的一个接口，它允许开发者在 BeanFactory 标准初始化之后，Bean 实例化之前对其进行修改或扩展。这个接口提供了一个方法，允许你在 Spring 容器的刷新过程中介入：

postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) 方法
- 这个方法在 BeanFactory 标准初始化之后，Bean 实例化之前调用。
- 它接收一个 ConfigurableListableBeanFactory 对象作为参数，这个对象提供了对 BeanFactory 的配置和操作能力。

:old_key: 扩展方式

这个接口是beanFactory的扩展接口，调用时机在spring在读取beanDefinition信息之后，实例化bean之前。

在这个时机，用户可以通过实现这个扩展接口来自行处理一些东西，比如修改已经注册的beanDefinition的元信息。

/**
 * @author XiaoSheng
 * @date 2024/8/18 下午8:06
 */
@Configuration
public class TestBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("[BeanFactoryPostProcessor]");
    }
}

:mailbox: 生效方式

使用@Configuration注解将该配置类添加到Spring容器中即可。

:man_playing_handball: 使用场景

当需要对 BeanFactory 进行动态修改，或者在 Bean 实例化之前需要进行一些特定的处理时，BeanFactoryPostProcessor 是一个非常有用的扩展点。

InstantiationAwareBeanPostProcessor

org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor

:open_book: 基本介绍

InstantiationAwareBeanPostProcessor 是 Spring 框架中的一个接口，它继承自 BeanPostProcessor 接口，并添加了一些方法，允许开发者在 Bean 实例化阶段执行自定义逻辑。这意味着你可以在 Bean 的构造函数被调用之前和之后介入 Bean 的创建过程。

该类主要的扩展点有以下5个方法，主要在bean生命周期的两大阶段：实例化阶段和初始化阶段，下面一起进行说明，按调用顺序为：

postProcessBeforeInstantiation：实例化bean之前，相当于new这个bean之前
postProcessAfterInstantiation：实例化bean之后，相当于new这个bean之后
postProcessPropertyValues：bean已经实例化完成，在属性注入时阶段触发，@Autowired,@Resource等注解原理基于此方法实现
postProcessBeforeInitialization：初始化bean之前，相当于把bean注入spring上下文之前
postProcessAfterInitialization：初始化bean之后，相当于把bean注入spring上下文之后

使用场景：这个扩展点非常有用，无论是写中间件和业务中，都能利用这个特性。比如对实现了某一类接口的bean在各个生命期间进行收集，或者对某个类型的bean进行统一的设值等等。

:old_key: 扩展方式

public class TestInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("[TestInstantiationAwareBeanPostProcessor] before initialization " + beanName);
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("[TestInstantiationAwareBeanPostProcessor] after initialization " + beanName);
        return bean;
    }

    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        System.out.println("[TestInstantiationAwareBeanPostProcessor] before instantiation " + beanName);
        return null;
    }

    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        System.out.println("[TestInstantiationAwareBeanPostProcessor] after instantiation " + beanName);
        return true;
    }

    @Override
    public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
        System.out.println("[TestInstantiationAwareBeanPostProcessor] postProcessPropertyValues " + beanName);
        return pvs;
    }

:mailbox: 生效方式

使用@Configuration注解将该配置类添加到Spring容器中即可。

:man_playing_handball: 使用场景

当需要在 Bean 的构造函数调用前后执行特定逻辑时。
当需要处理循环依赖或提前引用 Bean 时。

SmartInstantiationAwareBeanPostProcessor

org.springframework.beans.factory.config.SmartInstantiationAwareBeanPostProcessor

:open_book: 基本介绍

SmartInstantiationAwareBeanPostProcessor 是 Spring 框架中的一个接口，它是 InstantiationAwareBeanPostProcessor 接口的扩展，提供了更智能的 Bean 实例化控制。这个接口主要用于处理复杂的 Bean 实例化场景，比如处理 Bean 的循环依赖问题。

该扩展接口有3个触发点方法：

predictBeanType：该触发点发生在postProcessBeforeInstantiation之前(在图上并没有标明，因为一般不太需要扩展这个点)，这个方法用于预测Bean的类型，返回第一个预测成功的Class类型，如果不能预测返回null；当你调用BeanFactory.getType(name)时当通过bean的名字无法得到bean类型信息时就调用该回调方法来决定类型信息。
determineCandidateConstructors：该触发点发生在postProcessBeforeInstantiation之后，用于确定该bean的构造函数之用，返回的是该bean的所有构造函数列表。用户可以扩展这个点，来自定义选择相应的构造器来实例化这个bean。
getEarlyBeanReference：该触发点发生在postProcessAfterInstantiation之后，当有循环依赖的场景，当bean实例化好之后，为了防止有循环依赖，会提前暴露回调方法，用于bean实例化的后置处理。这个方法就是在提前暴露的回调方法中触发。

:old_key: 扩展方式

package cn.org.xiaosheng.beanPost;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.SmartInstantiationAwareBeanPostProcessor;
import org.springframework.context.annotation.Configuration;

import java.lang.reflect.Constructor;

/**
 * @author XiaoSheng
 * @date 2024/8/18 下午8:30
 */
@Configuration
public class TestSmartInstantiationAwareBeanPostProcessor implements SmartInstantiationAwareBeanPostProcessor {

    @Override
    public Class<?> predictBeanType(Class<?> beanClass, String beanName) throws BeansException {
        System.out.println("[TestSmartInstantiationAwareBeanPostProcessor] predictBeanType " + beanName);
        return beanClass;
    }

    @Override
    public Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName) throws BeansException {
        System.out.println("[TestSmartInstantiationAwareBeanPostProcessor] determineCandidateConstructors " + beanName);
        return null;
    }

    @Override
    public Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
        System.out.println("[TestSmartInstantiationAwareBeanPostProcessor] getEarlyBeanReference " + beanName);
        return bean;
    }
}

:mailbox: 生效方式

使用@Configuration注解将该配置类添加到Spring容器中即可。

:man_playing_handball: 使用场景

当需要对 Bean 的构造函数进行更精细的控制时，比如解决具有多个构造函数的 Bean 的实例化问题。
当需要处理 Bean 类型预测问题，比如在 Bean 定义中使用了泛型时。

注意:SmartInstantiationAwareBeanPostProcessor 的实现类会在 InstantiationAwareBeanPostProcessor 的实现类之前执行，因为它们提供了更智能的实例化逻辑。

ApplicationContextAwareProcessor

org.springframework.context.support.ApplicationContextAwareProcessor

:open_book: 基本介绍

ApplicationContextAwareProcessor 是 Spring 框架中的一个类，它实现了 BeanPostProcessor 接口，用于处理实现了 ApplicationContextAware 接口的 Bean。这个类是 Spring 容器自动装配（autowiring）过程中的一部分，确保所有实现了 ApplicationContextAware 接口的 Bean 都能接收到 ApplicationContext 的引用。

postProcessBeforeInitialization 方法：
- 这是 BeanPostProcessor 接口中的方法，ApplicationContextAwareProcessor 会重写这个方法。
- 在 Bean 的初始化之前，postProcessBeforeInitialization 被调用，ApplicationContextAwareProcessor 利用这个方法来检查 Bean 是否实现了 ApplicationContextAware 接口。
invokeAwareInterfaces 方法：
- 这个方法是 ApplicationContextAwareProcessor 的核心，它负责调用 ApplicationContextAware 接口的 setApplicationContext 方法。
- 如果检测到 Bean 实现了 ApplicationContextAware，invokeAwareInterfaces 会传递 ApplicationContext 的引用给这个 Bean。

扩展方法

EnvironmentAware：用于获取EnviromentAware的一个扩展类，这个变量非常有用，可以获得系统内的所有参数。当然个人认为这个Aware没必要去扩展，因为spring内部都可以通过注入的方式来直接获得。
EmbeddedValueResolverAware：用于获取StringValueResolver的一个扩展类， StringValueResolver用于获取基于String类型的properties的变量，一般我们都用@Value的方式去获取，如果实现了这个Aware接口，把StringValueResolver缓存起来，通过这个类去获取String类型的变量，效果是一样的。
ResourceLoaderAware：用于获取ResourceLoader的一个扩展类，ResourceLoader可以用于获取classpath内所有的资源对象，可以扩展此类来拿到ResourceLoader对象。
ApplicationEventPublisherAware：用于获取ApplicationEventPublisher的一个扩展类，ApplicationEventPublisher可以用来发布事件，结合ApplicationListener来共同使用，下文在介绍ApplicationListener时会详细提到。这个对象也可以通过spring注入的方式来获得。
MessageSourceAware：用于获取MessageSource的一个扩展类，MessageSource主要用来做国际化。
ApplicationContextAware：用来获取ApplicationContext的一个扩展类，ApplicationContext应该是很多人非常熟悉的一个类了，就是spring上下文管理器，可以手动的获取任何在spring上下文注册的bean，我们经常扩展这个接口来缓存spring上下文，包装成静态方法。同时ApplicationContext也实现了BeanFactory，MessageSource，ApplicationEventPublisher等接口，也可以用来做相关接口的事情。

:old_key: 扩展方式

该类本身并没有扩展点，但是该类内部却有6个扩展点可供实现，这些类触发的时机在bean实例化之后，初始化之前

SpringBoot启动扩展点今天具体聊一下SpringBoot的扩展点，SpringBoot框架也是对Spring框架

package cn.org.xiaosheng.applicationContext;

import org.springframework.context.EnvironmentAware;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;

/**
 * @author XiaoSheng
 * @date 2024/8/18 下午8:39
 */
@Configuration
public class TestEnviromentAware implements EnvironmentAware {

    @Override
    public void setEnvironment(Environment environment) {
        System.out.println("[TestEnviromentAware]" +environment);
    }
}

:mailbox: 生效方式

使用@Configuration注解将该配置类添加到Spring容器中即可。

:man_playing_handball: 使用场景

当需要确保某些 Bean 在初始化之前能够访问到 ApplicationContext 的时候。
当需要在 Bean 初始化过程中添加额外的逻辑，比如日志记录、性能监控等。

BeanNameAware

org.springframework.beans.factory.BeanNameAware

:open_book: 基本介绍

BeanNameAware 是 Spring 框架中的一个接口，它属于 Aware 系列接口之一。这个接口提供了一个方法，允许在 Spring 容器创建 Bean 时，将 Bean 的名称传递给 Bean 实例。这使得 Bean 可以知道自己在 Spring 容器中注册的名称。

可以看到，这个类也是Aware扩展的一种，触发点在bean的初始化之前，也就是postProcessBeforeInitialization之前，这个类的触发点方法只有一个：setBeanName

用户可以扩展这个点，在初始化bean之前拿到spring容器中注册的的beanName，来自行修改这个beanName的值。

:old_key: 扩展方式

/**
 * @author XiaoSheng
 * @date 2024/8/18 下午8:52
 */
@Configuration
public class NormalBeanA implements BeanNameAware {

    public NormalBeanA() {
        System.out.println("NormalBean constructor");
    }

    @Override
    public void setBeanName(String s) {
        if ("normalBeanA".equals(s)) {
            s = "xiaoshengBeanA";
        }
        System.out.println("[BeanNameAware] " + s);
    }
}

:mailbox: 生效方式

使用@Configuration注解将该配置类添加到Spring容器中即可。

:man_playing_handball: 使用场景

当 Bean 需要知道自己在 Spring 容器中的名称时。
当需要根据 Bean 名称进行特定的逻辑处理时。

@PostConstruct

javax.annotation.PostConstruct

:open_book: 基本介绍

PostConstruct 是一个注解，它属于 Java 的标准部分，用于标记在依赖注入完成之后，Bean 初始化之前执行的方法。这个注解通常与 Spring 框架一起使用，但它本身并不特定于 Spring，而是可以在任何实现了 Java 依赖注入（DI）的框架中使用。

这个并不算一个扩展点，其实就是一个标注。其作用是在bean的初始化阶段，如果对一个方法标注了@PostConstruct，会先调用这个方法。这里重点是要关注下这个标准的触发点，这个触发点是在postProcessBeforeInitialization之后，InitializingBean.afterPropertiesSet之前。

:old_key: 扩展方式

public class NormalBeanA {
    public NormalBeanA() {
        System.out.println("NormalBean constructor");
    }

    @PostConstruct
    public void init(){
        System.out.println("[PostConstruct] NormalBeanA");
    }
}

:mailbox: 生效方式

添加@PostConstruct注解即可生效

:man_playing_handball: 使用场景

使用场景：用户可以对某一方法进行标注，来进行初始化某一个属性

InitializingBean

org.springframework.beans.factory.InitializingBean

:open_book: 基本介绍

InitializingBean 是 Spring 框架中的一个接口，它定义了两个方法，专门用于处理 Bean 的初始化逻辑。当一个 Bean 实现了 InitializingBean 接口，它就可以提供自定义的初始化逻辑，这些逻辑将在 Bean 的属性设置完成之后执行。

它只包括afterPropertiesSet方法，凡是继承该接口的类，在初始化bean的时候都会执行该方法。这个扩展点的触发时机在postProcessAfterInitialization之前。

:old_key: 扩展方式

@Configuration
public class NormalBeanA implements InitializingBean{
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("[InitializingBean] NormalBeanA");
    }
}

:mailbox: 生效方式

使用@Configuration注解将该配置类添加到Spring容器中即可。

:man_playing_handball: 使用场景

用户实现此接口，来进行系统启动的时候一些业务指标的初始化工作。

FactoryBean

org.springframework.beans.factory.FactoryBean

:open_book: 基本介绍

FactoryBean 是 Spring 框架中的一个接口，它提供了一种机制，允许开发者定义自定义的工厂类，用以创建并管理复杂的 Bean 实例。FactoryBean 接口使得你可以控制实例的创建过程，并且可以返回一个对象，这个对象可能不是 Bean 工厂中的普通 Bean。

一般情况下，Spring通过反射机制利用bean的class属性指定支线类去实例化bean，在某些情况下，实例化Bean过程比较复杂，如果按照传统的方式，则需要在bean中提供大量的配置信息。配置方式的灵活性是受限的，这时采用编码的方式可能会得到一个简单的方案。Spring为此提供了一个org.springframework.bean.factory.FactoryBean的工厂类接口，用户可以通过实现该接口定制实例化Bean的逻辑。FactoryBean接口对于Spring框架来说占用重要的地位，Spring自身就提供了70多个FactoryBean的实现。它们隐藏了实例化一些复杂bean的细节，给上层应用带来了便利。从Spring3.0开始，FactoryBean开始支持泛型，即接口声明改为FactoryBean<T>的形式

:old_key: 扩展方式

public class TestFactoryBean implements FactoryBean<TestFactoryBean.TestFactoryInnerBean> {

    @Override
    public TestFactoryBean.TestFactoryInnerBean getObject() throws Exception {
        System.out.println("[FactoryBean] getObject");
        return new TestFactoryBean.TestFactoryInnerBean();
    }

    @Override
    public Class<?> getObjectType() {
        return TestFactoryBean.TestFactoryInnerBean.class;
    }

    @Override
    public boolean isSingleton() {
        return true;
    }

    public static class TestFactoryInnerBean{

    }
}

:man_playing_handball: 使用场景

用户可以扩展这个类，来为要实例化的bean作一个代理，比如为该对象的所有的方法作一个拦截，在调用前后输出一行log，模仿ProxyFactoryBean的功能。

SmartInitializingSingleton

org.springframework.beans.factory.SmartInitializingSingleton

:open_book: 基本介绍

SmartInitializingSingleton 是 Spring 框架中的一个接口，它允许开发者在所有单例 Bean 初始化完成之后执行一些自定义逻辑。这个接口主要用于在 Spring 容器中所有单例 Bean 完全初始化之后，执行一些清理或额外的初始化工作。

这个接口中只有一个方法afterSingletonsInstantiated，其作用是是在spring容器管理的所有单例对象（非懒加载对象）初始化完成之后调用的回调接口。其触发时机为postProcessAfterInitialization之后。

以下是 SmartInitializingSingleton 接口的核心 API ：

afterSingletonsInstantiated 方法：
- 这是 SmartInitializingSingleton 接口中定义的唯一方法。
- 该方法在所有单例 Bean 的 postConstruct 方法执行完毕并且所有初始化方法（包括 InitializingBean 的 afterPropertiesSet 和自定义的初始化方法）调用之后被调用。

:old_key: 扩展方式

public class TestSmartInitializingSingleton implements SmartInitializingSingleton {
    @Override
    public void afterSingletonsInstantiated() {
        System.out.println("[TestSmartInitializingSingleton]");
    }
}

:mailbox: 生效方式

使用@Configuration注解将该配置类添加到Spring容器中即可。

:man_playing_handball: 使用场景

用户可以扩展此接口在对所有单例对象初始化完毕后，做一些后置的业务处理。

当需要在所有 Bean 初始化完成后进行一些全局的设置或初始化工作时。
当需要在容器完全启动后执行一些特定的任务，比如发送通知、触发某些事件等。

CommandLineRunner

org.springframework.boot.CommandLineRunner

:open_book: 基本介绍

CommandLineRunner 是 Spring 框架中的一个接口，它提供了一种机制，允许开发者在应用程序启动并且所有的 Spring 管理的 Bean 都初始化完成后执行一些命令行代码。这通常用于执行一些启动时的脚本或命令，比如发送启动通知、执行健康检查等。

这个接口也只有一个方法：run(String... args)，触发时机为整个项目启动完毕后，自动执行。如果有多个CommandLineRunner，可以利用@Order来进行排序。

:old_key: 扩展方式

public class TestCommandLineRunner implements CommandLineRunner {

    @Override
    public void run(String... args) throws Exception {
        System.out.println("[TestCommandLineRunner]");
    }
}

:mailbox: 生效方式

使用@Configuration注解将该配置类添加到Spring容器中即可。

:man_playing_handball: 使用场景

当需要在应用程序启动后立即执行一些特定的命令或脚本时。
当需要根据命令行参数来调整应用程序的行为或配置时。
用户扩展此接口，进行启动项目之后一些业务的预处理。

DisposableBean

org.springframework.beans.factory.DisposableBean

:open_book: 基本介绍

这个扩展点也只有一个方法：destroy()，其触发时机为当此对象销毁时，会自动执行这个方法。比如说运行applicationContext.registerShutdownHook时，就会触发这个方法。

DisposableBean 是 Spring 框架中的一个接口，它定义了一个 destroy 方法，用于执行 Bean 的销毁逻辑。当 Spring 容器关闭时，实现了 DisposableBean 接口的 Bean 可以执行一些清理工作，比如关闭数据库连接、停止线程、释放资源等。

destroy 方法：
- 这是 DisposableBean 接口中定义的唯一方法。
- 这个方法在 Bean 销毁时被调用，允许执行自定义的销毁逻辑。

:old_key: 扩展方式

public class NormalBeanA implements DisposableBean {
    @Override
    public void destroy() throws Exception {
        System.out.println("[DisposableBean] NormalBeanA");
    }
}

:mailbox: 生效方式

使用@Configuration注解将该配置类添加到Spring容器中即可。

:man_playing_handball: 使用场景

当 Bean 需要在销毁时释放系统资源或执行其他清理工作时。
当需要确保 Bean 在销毁时能够正确地关闭或清理其持有的资源时。

ApplicationListener

org.springframework.context.ApplicationListener

:open_book: 基本介绍

ApplicationListener 是 Spring 框架中的一个接口，它属于事件发布/订阅模型的一部分。通过实现 ApplicationListener 接口，一个 Bean 可以注册为事件监听器，从而能够监听和响应 Spring 应用上下文中发布的事件。

ApplicationListener可以监听某个事件的event，触发时机可以穿插在业务方法执行过程中，用户可以自定义某个业务事件。但是spring内部也有一些内置事件，这种事件，可以穿插在启动调用中。我们也可以利用这个特性，来自己做一些内置事件的监听器来达到和前面一些触发点大致相同的事情。

ContextRefreshedEvent

ApplicationContext 被初始化或刷新时，该事件被发布。这也可以在ConfigurableApplicationContext接口中使用 refresh()方法来发生。此处的初始化是指：所有的Bean被成功装载，后处理Bean被检测并激活，所有Singleton Bean 被预实例化，ApplicationContext容器已就绪可用。

ContextStartedEvent

当使用 ConfigurableApplicationContext （ApplicationContext子接口）接口中的 start() 方法启动 ApplicationContext时，该事件被发布。你可以调查你的数据库，或者你可以在接受到这个事件后重启任何停止的应用程序。

ContextStoppedEvent

当使用 ConfigurableApplicationContext接口中的 stop()停止ApplicationContext 时，发布这个事件。你可以在接受到这个事件后做必要的清理的工作

ContextClosedEvent

当使用 ConfigurableApplicationContext接口中的 close()方法关闭 ApplicationContext 时，该事件被发布。一个已关闭的上下文到达生命周期末端；它不能被刷新或重启

RequestHandledEvent

这是一个 web-specific 事件，告诉所有 bean HTTP 请求已经被服务。只能应用于使用DispatcherServlet的Web应用。在使用Spring作为前端的MVC控制器时，当Spring处理用户请求结束后，系统会自动触发该事件

:old_key: 扩展方式

public class MyApplicationListener implements ApplicationListener<ContextRefreshedEvent> {

    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        // 处理 ContextRefreshedEvent 事件
        System.out.println("Application is refreshed!");
    }
}

:mailbox: 生效方式

事件监听器的执行顺序可以通过 @Order 或 @Priority 注解进行控制，如果没有指定，则按照注册顺序执行。

:man_playing_handball: 使用场景

当需要对应用程序中的某些事件做出响应时，比如用户登录、应用程序启动或关闭等。
当需要在应用程序的不同部分之间实现松耦合的通信时。

上述介绍的所有示例代码存放于gitee.com/Sheng-Sheng…

转载自:https://juejin.cn/post/7403949964973867043