扩展

1、背景

Spring的核心思想就是容器，当容器refresh的时候，外部看上去风平浪静，其实内部则是一片惊涛骇浪，汪洋一片。Springboot更是封装了Spring，遵循约定大于配置，加上自动装配的机制。很多时候我们只要引用了一个依赖，几乎是零配置就能完成一个功能的装配。

我非常喜欢这种自动装配的机制，所以在自己开发中间件和公共依赖工具的时候也会用到这个特性。让使用者以最小的代价接入。想要把自动装配玩的转，就必须要了解spring对于bean的构造生命周期以及各个扩展接口。当然了解了bean的各个生命周期也能促进我们加深对spring的理解。业务代码也能合理利用这些扩展点写出更加漂亮的代码。

在这篇文章里，我总结了几乎Spring & Springboot所有的扩展接口，以及各个扩展点的使用场景。并且整理出了一个bean在spring内部从被加载到最后初始化完成所有可扩展点的顺序调用图。从而我们也能窥探到bean是如何一步步加载到spring容器中的。

2、可扩展的接口启动调用顺序图

以下是spring容器中Bean的生命周期内所有可扩展的点的调用顺序，下面会一个个分析

3、ApplicationContextInitializer

org.springframework.context.ApplicationContextInitializer

这是整个spring容器在刷新之前初始化ConfigurableApplicationContext的回调接口，简单来说，就是在容器刷新之前调用此类的initialize方法。这个点允许被用户自己扩展。用户可以在整个spring容器还没被初始化之前做一些事情（允许开发者在加载任何 bean 之前对应用上下文进行定制）。

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

扩展方式为：

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

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

在启动类中用springApplication.addInitializers(new TestApplicationContextInitializer())语句加入
配置文件配置context.initializer.classes=com.example.demo.TestApplicationContextInitializer
Spring SPI扩展，在spring.factories中加入org.springframework.context.ApplicationContextInitializer=com.example.demo.TestApplicationContextInitializer

4、BeanDefinitionRegistryPostProcessor

org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor

这个接口在读取项目中的beanDefinition之后执行，提供一个补充的扩展点

使用场景

1、你可以在这里动态注册自己的beanDefinition，可以加载classpath之外的bean 2、在 Spring 容器加载了 Bean 定义后，但在实例化 Beans 之前，您可以使用这个接口来修改或添加 Bean 定义。 3、条件性的Bean注册：基于特定条件（比如环境变量或配置参数），动态地注册或修改 Bean。 4、自定义注解处理：如果你需要开发自己的注解并在 Spring 上下文中处理它们，可以使用这个接口。

扩展方式为:

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

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

生效方式

1、实现接口：您需要创建一个类实现 BeanDefinitionRegistryPostProcessor 接口，并重写 postProcessBeanDefinitionRegistry 和 postProcessBeanFactory 方法。 2、注册到Spring容器：可以通过注解（如 @Component）或在配置类中显式注册。 3、执行顺序：首先执行 postProcessBeanDefinitionRegistry 方法，允许添加或修改 Bean 定义。随后执行 postProcessBeanFactory 方法，这一步通常用于修改已经注册的 Bean 的属性

5、BeanFactoryPostProcessor

org.springframework.beans.factory.config.BeanFactoryPostProcessor

这个接口是beanFactory的扩展接口，调用时机在spring在读取beanDefinition信息之后，实例化bean之前。在这个时机，用户可以通过实现这个扩展接口来自行处理一些东西，比如修改已经注册的beanDefinition的元信息。

应用场景

修改或替换 Bean 定义：如果需要对 Spring 容器中的 Bean 定义进行修改或替换，可以实现此接口。 环境检查或配置：在 Spring 容器实例化 beans 之前，进行一些环境的检查或者对配置信息的修改。 动态注册 Bean 定义：可以动态地向 Spring 容器添加新的 Bean 定义

扩展方式为：

public class TestBeanFactoryPostProcessor implements BeanFactoryPostProcessor {      
    @Override      
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {      
        System.out.println("[BeanFactoryPostProcessor]");      
    }      
}

使用案例：

public class DataSourceBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

    private String url;
    private String username;
    private String password;

    // 构造函数和属性的 setter

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        BeanDefinition bd = beanFactory.getBeanDefinition("dataSource");
        MutablePropertyValues pv = bd.getPropertyValues();
        if (pv.contains("url")) {
            pv.add("url", url);
        }
        if (pv.contains("username")) {
            pv.add("username", username);
        }
        if (pv.contains("password")) {
            pv.add("password", password);
        }
    }
}

6、InstantiationAwareBeanPostProcessor

org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor

该接口继承了BeanPostProcess接口，区别如下：

BeanPostProcess接口只在bean的初始化阶段进行扩展（注入spring上下文前后），而InstantiationAwareBeanPostProcessor接口在此基础上增加了3个方法，把可扩展的范围增加了实例化阶段和属性注入阶段。

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

postProcessBeforeInstantiation：实例化bean之前，相当于new这个bean之前，可用于修改动态环境 RocketMQ 消费者组名称，以及一些中间件 bean 属性的动态修改
postProcessAfterInstantiation：实例化bean之后，相当于new这个bean之后
postProcessPropertyValues：bean已经实例化完成，在属性注入时阶段触发，@Autowired,@Resource等注解原理基于此方法实现
postProcessBeforeInitialization：初始化bean之前，相当于把bean注入spring上下文之前
postProcessAfterInitialization：初始化bean之后，相当于把bean注入spring上下文之后

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

扩展方式为：

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;      
    }

6.1、使用案例

@Slf4j
public class DynamicRocketMQPostProcessor implements InstantiationAwareBeanPostProcessor {

    @Value("${spring.profiles.active}")
    String envProfile;

    @Autowired
    Environment env;

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (StringUtils.isEmpty(envProfile) || (!envProfile.contains(DynamicEnvManager.DEV_ENV) && !envProfile.contains(DynamicEnvManager.TEST_ENV))) {
            return bean;
        }

        if (bean instanceof RocketMQListener) {
            try {
                log.info("postProcessProperties bean -> {} beanName -> {}", bean, beanName);
                RocketMQListener<?> rocketMQListener = (RocketMQListener<?>) bean;
                Class<? extends RocketMQListener> rocketmqListener = rocketMQListener.getClass();

                RocketMQMessageListener annotation = rocketmqListener.getAnnotation(RocketMQMessageListener.class);

                //获取 这个代理实例所持有的 InvocationHandler
                InvocationHandler invocationHandler = Proxy.getInvocationHandler(annotation);

                // 获取 AnnotationInvocationHandler 的 memberValues 字段
                Field declaredField = invocationHandler.getClass().getDeclaredField("memberValues");

                // 因为这个字段事 private final 修饰，所以要打开权限
                declaredField.setAccessible(true);

                // 获取 memberValues
                Map memberValues = (Map) declaredField.get(invocationHandler);

                // 修改 value 属性值
                String oldConsumer = annotation.consumerGroup();

                String property = env.getProperty(DynamicEnvManager.GLOBAL_ENV_NAME);
                if (StringUtils.isBlank(property)) {
                    property = "";
                    log.error("postProcessBeforeInitialization env error property -> {}", property);
                }
                String newConsumer = oldConsumer + property;
                memberValues.put("consumerGroup", newConsumer);

                log.info("postProcessBeforeInitialization annotation -> {} oldConsumer -> {} newConsumer -> {} ", annotation, oldConsumer, newConsumer);
            } catch (Exception e) {
                log.error("postProcessBeforeInitialization consumerGroup replace error : ", e);
            }
        }
        return bean;
    }

}

7、SmartInstantiationAwareBeanPostProcessor

org.springframework.beans.factory.config.SmartInstantiationAwareBeanPostProcessor

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

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

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.SmartInstantiationAwareBeanPostProcessor;
import java.lang.reflect.Constructor;

public class CustomSmartBeanPostProcessor implements SmartInstantiationAwareBeanPostProcessor {

    @Override
    public Class<?> predictBeanType(Class<?> beanClass, String beanName) throws BeansException {
        // 在这里，根据beanName或beanClass预测Bean的类型
        if (beanName.equals("mySpecialBean")) {
            return MySpecialBeanImpl.class;
        }
        return null;
    }

    @Override
    public Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName) throws BeansException {
        // 在这里，可以自定义选择哪个构造器用于实例化Bean
        // 例如，根据特定条件选择合适的构造函数
        if (beanClass.equals(MyBean.class)) {
            // 尝试获取MyBean的特定构造函数
            try {
                return new Constructor<?>[] { beanClass.getConstructor(MyDependency.class) };
            } catch (NoSuchMethodException e) {
                // 处理异常
            }
        }
        return null;
    }

    @Override
    public Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
        // 在这里处理循环依赖的场景，返回Bean的早期引用
        // 通常用于AOP代理或特殊处理
        return bean;
    }

    // 其他必要的方法实现...
}

8、BeanFactoryAware

org.springframework.beans.factory.BeanFactoryAware

这个类只有一个触发点，发生在bean的实例化之后，注入属性之前，也就是Setter之前。这个类的扩展点方法为setBeanFactory，可以拿到BeanFactory这个属性。

使用场景为，你可以在bean实例化之后，但还未初始化之前，拿到 BeanFactory，在这个时候，可以对每个bean作特殊化的定制。也或者可以把BeanFactory拿到进行缓存，日后使用。

扩展方式为：

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;

public class CustomBeanFactoryAwareClass implements BeanFactoryAware {

    private BeanFactory beanFactory;

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = beanFactory;
        // 执行额外的初始化或配置逻辑
        initializeCustomBeans();
    }

    private void initializeCustomBeans() {
        // 在这里，您可以使用 beanFactory 来创建或配置 Bean
        // 例如，根据条件动态创建 Bean
        if (/* 某个条件 */) {
            MyBean myBean = beanFactory.getBean(MyBean.class);
            // 使用 myBean 进行操作
        }
    }

    // 其他自定义方法...
}

9、ApplicationContextAwareProcessor

org.springframework.context.support.ApplicationContextAwareProcessor

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

图片

可以看到，该类用于执行各种驱动接口，在bean实例化之后，属性填充之后，通过执行以上红框标出的扩展接口，来获取对应容器的变量。所以这里应该来说是有6个扩展点，这里就放一起来说了

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等接口，也可以用来做相关接口的事情。

import org.springframework.context.*;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.support.MessageSourceAccessor;
import org.springframework.core.env.Environment;
import org.springframework.context.MessageSource;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.core.io.ResourceLoader;
import org.springframework.util.StringValueResolver;

public class MyAwareBean implements EnvironmentAware, EmbeddedValueResolverAware,
        ResourceLoaderAware, ApplicationEventPublisherAware, MessageSourceAware,
        ApplicationContextAware {

    private Environment environment;
    private StringValueResolver stringValueResolver;
    private ResourceLoader resourceLoader;
    private ApplicationEventPublisher applicationEventPublisher;
    private MessageSourceAccessor messageSourceAccessor;
    private ApplicationContext applicationContext;

    @Override
    public void setEnvironment(Environment environment) {
        this.environment = environment;
    }

    @Override
    public void setEmbeddedValueResolver(StringValueResolver resolver) {
        this.stringValueResolver = resolver;
    }

    @Override
    public void setResourceLoader(ResourceLoader resourceLoader) {
        this.resourceLoader = resourceLoader;
    }

    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
        this.applicationEventPublisher = applicationEventPublisher;
    }

    @Override
    public void setMessageSource(MessageSource messageSource) {
        this.messageSourceAccessor = new MessageSourceAccessor(messageSource);
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
    }

    // 使用注入的依赖来实现一些业务逻辑
    public void performSomeAction() {
        // 示例：使用environment获取属性
        String dbUrl = environment.getProperty("database.url");

        // 示例：使用stringValueResolver解析字符串
        String resolvedString = stringValueResolver.resolveStringValue("some.value");

        // 示例：使用resourceLoader加载资源
        // Resource resource = resourceLoader.getResource("classpath:test.txt");

        // 示例：发布事件
        // applicationEventPublisher.publishEvent(new MyEvent(this));

        // 示例：使用messageSourceAccessor获取国际化消息
        // String message = messageSourceAccessor.getMessage("some.message.key");

        // 示例：使用applicationContext获取bean
        // MyOtherBean otherBean = applicationContext.getBean(MyOtherBean.class);
    }
}

10、BeanNameAware

org.springframework.beans.factory.BeanNameAware

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

日志记录：Bean可以在日志中记录自己的名字，这对于调试和跟踪Bean的创建及其在容器中的生命周期是非常有用的。
依赖注入：在某些复杂的依赖注入场景中，Bean可能需要知道自己的名字来动态地处理依赖关系，尤其是在存在多个相同类型但需要不同处理的Bean时。
上下文感知：对于需要根据其在容器中的角色或标识来改变行为的Bean，了解自己的名字是很重要的。例如，同一个类的不同实例可能需要根据其在Spring容器中的名字来加载不同的配置。
与其他框架集成：在集成Spring与其他框架（如Quartz, Apache Camel等）时，知道Bean的名字可以帮助在框架之间传递信息，确保正确的配置和交互。
测试和模拟：在测试环境中，可以利用Bean的名字进行模拟或者特定的测试设置。

扩展方式为：

import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class MyCustomBean implements BeanNameAware, InitializingBean {

    private String beanName;

    @Autowired
    private SomeOtherBean someOtherBean;

    @Override
    public void setBeanName(String name) {
        this.beanName = name;
        // 在这里可以进行与bean名字相关的初始化操作
        System.out.println("Bean的名字是: " + name);
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        // 当所有属性被设置后，Spring会调用这个方法
        // 可以在这里执行一些初始化的逻辑
        System.out.println("正在初始化Bean: " + beanName);
    }

    // Bean的其他业务方法
    public void doSomething() {
        // 方法实现
    }

    // ... 其他可能的方法和逻辑
}

11、@PostConstruct

javax.annotation.PostConstruct

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

资源初始化：在数据库连接、读取配置文件或者初始化一些数据结构时使用。
日志记录：应用启动时，记录一些启动日志或者系统状态。
数据预加载：预加载一些必要的数据到缓存中。
检查依赖：确保应用的某些依赖项已经准备就绪。

扩展方式为：

import javax.annotation.PostConstruct;

public class MyService {

    // 依赖注入的示例字段
    private DependencyClass dependency;

    public MyService(DependencyClass dependency) {
        this.dependency = dependency;
    }

    @PostConstruct
    public void init() {
        // 初始化逻辑
        System.out.println("依赖注入完成，执行初始化操作");
        // 比如，使用dependency进行一些设置或调用
    }

    // 类的其他方法...
}

12、InitializingBean

org.springframework.beans.factory.InitializingBean

这个类，顾名思义，也是用来初始化bean的。InitializingBean接口为bean提供了初始化方法的方式，它只包括afterPropertiesSet方法，凡是继承该接口的类，在初始化bean的时候都会执行该方法。这个扩展点的触发时机在postProcessAfterInitialization之前。

资源初始化：如数据库连接、文件系统的访问或其他需要在属性设置后进行初始化的资源。
自定义配置校验：在bean的属性被注入后，检查或校验这些属性。
复杂的初始化逻辑：执行复杂的初始化逻辑，这些逻辑可能依赖于多个属性

扩展方式为：

import org.springframework.beans.factory.InitializingBean;

public class MyService implements InitializingBean {

    // 依赖注入的示例字段
    private DependencyClass dependency;

    public void setDependency(DependencyClass dependency) {
        this.dependency = dependency;
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        // 执行初始化逻辑
        System.out.println("所有属性设置完成，执行初始化操作");
        // 例如，使用dependency进行一些设置或调用
    }

    // 类的其他方法...
}

13、FactoryBean

org.springframework.beans.factory.FactoryBean

一般情况下，Spring通过反射机制利用bean的class属性指定支线类去实例化bean，在某些情况下，实例化Bean过程比较复杂，如果按照传统的方式，则需要在bean中提供大量的配置信息。配置方式的灵活性是受限的，这时采用编码的方式可能会得到一个简单的方案。Spring为此提供了一个org.springframework.bean.factory.FactoryBean的工厂类接口，用户可以通过实现该接口定制实例化Bean的逻辑。

FactoryBean接口对于Spring框架来说占用重要的地位，Spring自身就提供了70多个FactoryBean的实现。它们隐藏了实例化一些复杂bean的细节，给上层应用带来了便利。从Spring3.0开始，FactoryBean开始支持泛型，即接口声明改为FactoryBean的形式

复杂对象的创建：当一个对象的创建过程非常复杂，例如需要多步构建过程或特定的配置逻辑时。
依赖注入之外的控制：如果需要在标准依赖注入之外控制对象的创建逻辑。
单例与非单例的管理：可以灵活地创建单例或原型（非单例）对象。
创建特定类型的资源：例如连接到特定服务的代理或特殊类型的资源。

扩展方式为：

import org.springframework.beans.factory.FactoryBean;

public class MyFactoryBean implements FactoryBean<MyObject> {

    @Override
    public MyObject getObject() throws Exception {
        // 创建并返回一个MyObject实例
        MyObject myObject = new MyObject();
        // 可以在这里进行复杂的构建逻辑
        return myObject;
    }

    @Override
    public Class<?> getObjectType() {
        // 返回创建对象的类型
        return MyObject.class;
    }

    @Override
    public boolean isSingleton() {
        // 控制是否单例
        // 返回true表示创建的对象是单例
        // 返回false表示创建的对象是非单例
        return true;
    }

    // 其他可能的自定义方法或逻辑...
}

14、SmartInitializingSingleton

org.springframework.beans.factory.SmartInitializingSingleton

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

后处理逻辑：在所有单例bean初始化完成之后执行一些后处理操作，例如数据校验、缓存预热等。
依赖于多个Bean的初始化：当你的逻辑需要确保多个其他bean已经初始化完成时使用。
异步操作的启动：如启动异步任务，当所有必要的bean都已经准备好。
复杂的启动流程：例如，当应用需要在启动时执行一系列复杂的初始化步骤

扩展方式为：

import org.springframework.beans.factory.SmartInitializingSingleton;
import org.springframework.stereotype.Component;

@Component
public class MySmartSingleton implements SmartInitializingSingleton {

    // 依赖注入的其他Bean
    private final AnotherBean anotherBean;

    public MySmartSingleton(AnotherBean anotherBean) {
        this.anotherBean = anotherBean;
    }

    @Override
    public void afterSingletonsInstantiated() {
        // 执行一些后处理逻辑
        System.out.println("所有单例Bean都已经初始化，执行特定操作");
        // 可以使用anotherBean进行一些操作
    }

    // 其他方法...
}

15、CommandLineRunner

org.springframework.boot.CommandLineRunner

这个接口也只有一个方法：run(String... args)，触发时机为整个项目启动完毕后，自动执行。如果有多个CommandLineRunner，可以利用@Order来进行排序。接口用于在Spring应用启动后执行特定的代码。它提供了一种简单的方法来访问命令行参数，并在Spring应用上下文加载完成后立即执行一些操作。

命令行参数处理：解析和处理传递给Spring应用的命令行参数。
启动时数据初始化：在应用启动时加载数据，例如从文件读取数据或者数据库初始化。
启动后的检查：进行一些启动后的健康检查或者环境检查。
启动任务：如启动一个定时任务或触发一些仅需执行一次的操作。

扩展方式为：

import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

@Component
public class MyCommandLineRunner implements CommandLineRunner {

    @Override
    public void run(String... args) throws Exception {
        // 执行一些启动逻辑
        System.out.println("Spring应用已启动，执行命令行处理");
        // args包含传递给应用程序的命令行参数
        for (String arg : args) {
            System.out.println(arg);
        }
    }

    // 其他方法...
}

16、DisposableBean

org.springframework.beans.factory.DisposableBean

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

扩展方式为：

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

17、ApplicationListener

org.springframework.context.ApplicationListener

准确的说，这个应该不算spring&springboot当中的一个扩展点，ApplicationListener可以监听某个事件的event，触发时机可以穿插在业务方法执行过程中，用户可以自定义某个业务事件。

但是spring内部也有一些内置事件，这种事件，可以穿插在启动调用中。我们也可以利用这个特性，来自己做一些内置事件的监听器来达到和前面一些触发点大致相同的事情。

接下来罗列下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处理用户请求结束后，系统会自动触发该事件

18、最后

我们从这些spring&springboot的扩展点当中，大致可以窥视到整个bean的生命周期。在业务开发或者写中间件业务的时候，可以合理利用spring提供给我们的扩展点，在spring启动的各个阶段内做一些事情。以达到自定义初始化的目的。

Keys	Action
`?`	Open this help
`n`	Next page
`p`	Previous page
`s`	Search