Spring IOC容器初始化后，执行一些逻辑操作的几种实现方式

写在开篇
在项目的开发中，通常都会用到 Spring 来进行项目管理。在某些应用中，我们希望当Spring 容器将所有的 Bean 都初始化完成后，做一个操作（例如：将数据库中的字典，加载到内存中）。那么如何在 Spring IOC 容器初始化完成后，自动触发某个方法来完成某些业务逻辑配置相关的操作执行呢？一共能找到的介绍有如下7种，但是这7种还各自都有些不同之处。
解析8种实现方式

  1. 类实现ApplicationContextAware，重写setApplicationContext()方法
  2. 类实现InitializingBean，重写afterPropertiesSet()方法
  3. 在类中的方法上，添加@PostConstruct注解。（@PreDestroy注销时使用）
  4. 类实现BeanPostProcessor，重写postProcessBeforeInitialization()、postProcessAfterInitialization()方法
  5. 类实现 SmartLifecycle，重写相关方法
  6. 类实现ApplicationContextListener，重写onApplicationEvent()方法
  7. 类实现ApplicationRunner，重写run()方法
  8. 类实现CommandLineRunner，重写run()方法

说明：
第 1 、2 种方式，是在所有 bean 对象注册到 IOC 容器完成之后，通过 后置处理器 或者Spring 启动后的其他后置操作，来针对指定实现 ApplicationContextAware 或 InitializingBean 的一个bean类进行操作，达到配置全局的目的。比如说：将数据库中的字典，加载到内存中 这种，并不需要每一个bean都配置的功能。(提示：说到底第1、2种方式，和本文提及的 Spring IOC 初始化后。还是有一些出入的，本文也就一并都放到这里介绍了)
第 3 种方式，PostConstruct和 Spring 的启动流程无关，只和 Servlet 容器相关。(提示：Spring 项目在启动 Servlet(此处以 Tomcat 为例)时，已经完成了 IOC 的相关操作，满足本文题目在 Spring IOC 初始化后)
第 4 种方式，BeanPostProcessor是对 Spring IOC 容器中每个bean对象的前置、后置增强。(提示：也和本文要求 Spring IOC 容器初始化后有出入。本文也就一并都放到这里介绍了))
第 5 种方式，根据源码我们了解到 LifecycleProcessor 处理器是在Spring 容器启动最后一步 Last step: finishRefresh();这个方法中调用到的(提示：此时 Spring IOC 容器的初始化工作已经完成满足本文题目在 Spring IOC 初始化后)
第 6 种方式，使用 ApplicationListener 监听机制。监听 ApplicationContextListener<ContextRefreshedEvent>的方式，Spring IOC 容器在所有的bean都初始化完成并被成功装载后会触发该事件(提示：监听器方式 也可以满足本文题目在 Spring IOC 初始化后，执行部分逻辑操作)
第 7、8 种方式，实现 ApplicationRunner、CommandLineRunner 接口的方式。都是在容器启动完成的时执行。(提示：这种方式也可以满足本文题目在 Spring IOC 初始化后，执行部分逻辑操作)
综合来说： 只有3、5、6、7、8 这五种方式，是彻底在 Spring IOC容器初始化后，执行一些逻辑操作。其它三种方式只能说是变相满足本文要求吧

使用介绍
1.实现ApplicationContextAware，重写setApplicationContext()方法
实现ApplicationContextAware接口并重写setApplicationContext()方法获取ApplicationContext实例，这个要追溯到ApplicationContextAwareProcessor类。首先我们来看一下 ApplicationContextAwareProcessor 这个类，它是BeanPostProcessor(后置处理器)的一个实现类，此处附 Spring 启动源码来了解这个后置处理器。
此处源码分析， 你可参考：Spring IOC 源码解析一文学习更清晰。根据代码，重点：在注册后置处理器时，Spring IOC 容器已经初始化完成，所以我们可以通过这种方式，在 IOC 容器初始化后，执行一些逻辑操作。

复制代码
@Override
public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        // Prepare this context for refreshing.
        prepareRefresh();

        //1.此处 obtainFreshBeanFactory()方法，来完成Spring IOC容器的 定位、加载、注册 等操作
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // Prepare the bean factory for use in this context.
        prepareBeanFactory(beanFactory);

        try {
            // Allows post-processing of the bean factory in context subclasses.
            postProcessBeanFactory(beanFactory);

            // Invoke factory processors registered as beans in the context.
            invokeBeanFactoryPostProcessors(beanFactory);

            // Register bean processors that intercept bean creation.
            //2.此处用来注册配置后置处理器(说明在配置后置处理器时，IOC容器已经创建完成)
            registerBeanPostProcessors(beanFactory);

            //省略部分源码
        } catch (BeansException ex) {
            // Destroy already created singletons to avoid dangling resources.
            destroyBeans();

            // Reset 'active' flag.
            cancelRefresh(ex);
        } finally {
            resetCommonCaches();
        }
    }
}
复制代码

示例：(本例使用 Spring Boot框架)

复制代码
@Component
public class AfterIocInitialConfig implements ApplicationContextAware {

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        //在此处执行逻辑操作
        System.out.println("--ApplicationContextAware-------在此执行一些逻辑操作");
    }


}
复制代码

2.实现InitializingBean，重写afterPropertiesSet()方法
（bean 配置文件属性 init-method 用于在bean初始化时指定执行方法，可以用来替代继承 InitializingBean接口）
InitializingBean接口为bean提供了初始化方法的方式，它只包括afterPropertiesSet()方法，凡是继承该接口的类，在初始化 bean 的时候都会执行该方法。(注意：重写了InitializingBean的 bean 在初始化时才会执行，没重写的 bean 是不会被执行的)

复制代码
@Override
public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        // Prepare this context for refreshing.
        prepareRefresh();

        //1.此处 obtainFreshBeanFactory()方法，来完成Spring IOC容器的 定位、加载、注册 等操作
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // Prepare the bean factory for use in this context.
        prepareBeanFactory(beanFactory);

        try {
            // 省略部分代码
            
            // Instantiate all remaining (non-lazy-init) singletons.
            //2.初始化所有的单例 bean(实现InitializingBean,重写afterPropertiesSet()方法,在此处执行)
            finishBeanFactoryInitialization(beanFactory);

            // Last step: publish corresponding event.
            finishRefresh();

            //省略部分源码
        } catch (BeansException ex) {
            // Destroy already created singletons to avoid dangling resources.
            destroyBeans();

            // Reset 'active' flag.
            cancelRefresh(ex);
        } finally {
            resetCommonCaches();
        }
    }
}
复制代码

示例：(本例使用 Spring Boot框架)

复制代码
@Component
public class InitializingBeanAfterIocInitialConfig implements InitializingBean {

    @Override
    public void afterPropertiesSet() throws Exception {
        //在此处执行逻辑操作
        System.out.println("--InitializingBean------在此执行一些逻辑操作");
    }

}
复制代码

3. 在类中的方法上，添加@PostConstruct注解。（@PreDestroy注销时使用）
@PostConstruct 说明：
被 @PostConstruct 修饰的方法会在服务器加载 Servlet 的时候运行，并且只会被服务器调用一次，类似于 Servlet 的 init() 方法。被@PostConstruct 修饰的方法会在构造函数之后，init() 方法之前运行。
@PostConstruct 注释用于在依赖关系注入完成之后需要执行的方法上，以执行任何初始化。此方法必须在将类放入服务之前调用。支持依赖关系注入的所有类都必须支持此注释。即使类没有请求注入任何资源，用@PostConstruct 注释的方法也必须被调用。注意：只有一个方法可以用此注释进行注释。
@PreDestroy 说明：
被 @PreDestroy 修饰的方法会在服务器卸载 Servlet 的时候运行，并且只会被服务器调用一次，类似于 Servlet 的 destroy() 方法。被 @PreDestroy 修饰的方法会在 destroy() 方法之后运行，在 Servlet 被彻底卸载之前。
@PreDestroy 注释作为回调通知用于各方法，以表示该实例正处于被容器移除的过程中。用 @PreDestroy 注释的方法通常用于释放它已经持有的资源，所有支持 @PostConstruct 的容器管理对象都必须支持此注释

  • 应用 @PostConstruct、@PreDestroy 注释的方法必须遵守以下所有标准：
  • 该方法不得有任何参数，除非是在EJB 拦截器(interceptor)的情况下，它可以带有一个 InvocationContext 对象；
  • 该方法的返回类型必须为 void；
  • 该方法不得抛出已检查异常；
  • 应用@PostConstruct 的方法可以使 pulbic、protected、package private 或 private；
  • 除了应用程序客户端之外，该方法不能是 static；该方法可以是 final；

示例：(本例使用 Spring Boot框架)

复制代码
@Component
public class PostConstructConfig {

    //在服务器加载 Servlet 的时候执行
    @PostConstruct
    public void doSomething() {
        //在此处执行逻辑操作
        System.out.println("--PostConstruct------在此执行一些逻辑操作");
    }

    //在服务器卸载 Servlet 的时候执行
    @PreDestroy
    public void shutDownDoSomething() {
        System.out.println("--PostConstruct------卸载Servlet时执行");
    }
}
复制代码

@PostConstruct 注解，显然和 Spring IOC容器的启动没有多大关系，它只和 Servlet 容器的加载有关系。加载 Servlet 时， IOC 容器其实已经初始化完成。所以使用 @PostConstruct 注解，可以满足 Spring IOC 容器初始化后，执行一些逻辑操作。

4.类实现BeanPostProcessor接口，重写postProcessBeforeInitialization()、postProcessAfterInitialization()方法
BeanPostProcessor是 Spring IOC 容器给我们提供的一个扩展接口。注意：该接口会在 Spring IOC 容器的每一个 bean 初始化前、后做一些相关操作，记住是每一个!!!。接口声明如下：

public interface BeanPostProcessor {
    //bean初始化方法调用前被调用
    Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;
    //bean初始化方法调用后被调用
    Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
}

比如说当前 IOC 容器，有200个bean对象。那么这200个bean对象都会在初始化前、后来调用被重写的postProcessBeforeInitialization()、postProcessAfterInitialization()方法，相当于是 bean 对象初始化的前置、后置增强。

复制代码
@Component
public class BeanPostProcessorConfig implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("--BeanPostProcessor--" + beanName + ":对象初始化前执行一些操作");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("--BeanPostProcessor--" + beanName +":对象初始化后执行一些操作");
        return bean;
    }
}
复制代码

5.类实现 SmartLifecycle，重写相关方法
在使用 Spring 开发时，我们都知道，所有 bean都交给 Spring IOC 容器来统一管理，其中包括每一个 bean 的加载和初始化。有时候，我们需要在 Spring 加载和初始化所有bean后，接着执行一些任务或者启动需要的异步服务，这样我们可以使用 SmartLifecycle 来做到。SmartLifecycle 是一个接口，继承自 Lifecycle(生命周期)、Phased(如果有多个实现 Liftcycle接口的类，通过getPhase()方法来确定执行先后顺序)两个接口。当 Spring 容器加载所有 bean 并完成初始化之后，会接着回调实现该接口的类中对应的方法（start()方法）。
LifecycleProcessor 处理器，在源码中的执行位置，如下所示：

复制代码
@Override
public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        // Prepare this context for refreshing.
        prepareRefresh();

        // Tell the subclass to refresh the internal bean factory.
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // Prepare the bean factory for use in this context.
        prepareBeanFactory(beanFactory);

        try {
            // Allows post-processing of the bean factory in context subclasses.
            postProcessBeanFactory(beanFactory);

            //省略

            // Last step: publish corresponding event.
            // 重点：LifecycleProcessor 在此处被调用(继续进入方法查看)
            finishRefresh();
        }

        catch (BeansException ex) {
            //省略
        }

        finally {
            resetCommonCaches();
        }
    }
}


protected void finishRefresh() {

    // Initialize lifecycle processor for this context.
    // 重点1：为当前context初始化 LifecycleProcessor()
    initLifecycleProcessor();

    // Propagate refresh to lifecycle processor first.
    // 重点2：调用 lifecycleProcessor 的 onRefresh() 方法(如果我们定义了一个类，实现了 lifecycle 相关接口，则会在此处调用自定义的 onRefresh() 方法)
    getLifecycleProcessor().onRefresh();

    // Publish the final event.
    // 事件机制发布(在下一种实现方式 ApplicationContextListener 中会涉及到)
    publishEvent(new ContextRefreshedEvent(this));

    // Participate in LiveBeansView MBean, if active.
    LiveBeansView.registerApplicationContext(this);
}
复制代码

如果IOC容器没有 lifecycleProcessor,则会使用 DefaultLifecycleProcessor 类，此处附DefaultLifecycleProcessor 类源码（省略部分源码）

复制代码
public class DefaultLifecycleProcessor implements LifecycleProcessor, BeanFactoryAware {

    private volatile long timeoutPerShutdownPhase = 30000;

    private volatile boolean running;
    
    /**
     * Specify the maximum time allotted in milliseconds for the shutdown of
     * any phase (group of SmartLifecycle beans with the same 'phase' value).
     * <p>The default value is 30 seconds.
     */
    public void setTimeoutPerShutdownPhase(long timeoutPerShutdownPhase) {
        this.timeoutPerShutdownPhase = timeoutPerShutdownPhase;
    }
    
    /**
     * Start all registered beans that implement {@link Lifecycle} and are <i>not</i>
     * already running. Any bean that implements {@link SmartLifecycle} will be
     * started within its 'phase', and all phases will be ordered from lowest to
     * highest value. All beans that do not implement {@link SmartLifecycle} will be
     * started in the default phase 0. A bean declared as a dependency of another bean
     * will be started before the dependent bean regardless of the declared phase.
     */
    @Override
    public void start() {
        startBeans(false);
        this.running = true;
    }

    /**
     * Stop all registered beans that implement {@link Lifecycle} and <i>are</i>
     * currently running. Any bean that implements {@link SmartLifecycle} will be
     * stopped within its 'phase', and all phases will be ordered from highest to
     * lowest value. All beans that do not implement {@link SmartLifecycle} will be
     * stopped in the default phase 0. A bean declared as dependent on another bean
     * will be stopped before the dependency bean regardless of the declared phase.
     */
    @Override
    public void stop() {
        stopBeans();
        this.running = false;
    }

    @Override
    public void onRefresh() {
        startBeans(true);
        this.running = true;
    }

    @Override
    public void onClose() {
        stopBeans();
        this.running = false;
    }

    @Override
    public boolean isRunning() {
        return this.running;
    }
}
复制代码

示例：(本例使用 Spring Boot框架)

复制代码
@Component
public class SmartLifecycleConfig implements SmartLifecycle, ApplicationContextAware {


    private boolean isRunning = false;

    private ApplicationContext context = null;

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

    /**
     * 1. 我们主要在该方法中启动任务或者其他异步服务，比如开启MQ接收消息
     * 2. 当上下文被刷新（所有对象已被实例化和初始化之后）时，将调用该方法，默认生命周期处理器将检查每个SmartLifecycle对象的isAutoStartup()方法返回的布尔值。
     * 如果为“true”，则该方法会被调用，而不是等待显式调用自己的start()方法。
     */
    @Override
    public void start() {
        System.out.println("---SmartLifecycle--执行start()方法");
        // 执行完其他业务后，可以修改 isRunning = true
        isRunning = true;
    }

    /**
     * 如果工程中有多个实现接口SmartLifecycle的类，则这些类的start的执行顺序按getPhase方法返回值从小到大执行。
     * 例如：1比2先执行，-1比0先执行。 stop方法的执行顺序则相反，getPhase返回值较大类的stop方法先被调用，小的后被调用。
     */
    @Override
    public int getPhase() {
        // 默认为0
        System.out.println("---SmartLifecycle--执行getPhase方法");
        return 0;
    }

    /**
     * 根据该方法的返回值决定是否执行start方法。
     * 返回true时start方法会被自动执行，返回false则不会。
     */
    @Override
    public boolean isAutoStartup() {
//        return false;
        System.out.println("---SmartLifecycle--执行 isAutoStartup 方法");
        return true;
    }

    /**
     * SmartLifecycle子类才有的方法，当isRunning方法返回true时，该方法才会被调用。
     */
   /*@Override
    public void stop(Runnable callback) {
        System.out.println("stop(Runnable)");

        // 如果你让isRunning返回true，需要执行stop这个方法，那么就不要忘记调用callback.run()。
        // 否则在你程序退出时，Spring的DefaultLifecycleProcessor会认为你这个TestSmartLifecycle没有stop完成，程序会一直卡着结束不了，等待一定时间（默认超时时间30秒）后才会自动结束。
        // PS：如果你想修改这个默认超时时间，可以按下面思路做，当然下面代码是springmvc配置文件形式的参考，在SpringBoot中自然不是配置xml来完成，这里只是提供一种思路。
        // <bean id="lifecycleProcessor" class="org.springframework.context.support.DefaultLifecycleProcessor">
        //      <!-- timeout value in milliseconds -->
        //      <property name="timeoutPerShutdownPhase" value="10000"/>
        // </bean>
        callback.run();

        isRunning = false;
    }*/


    /**
     * 1. 只有该方法返回false时，start方法才会被执行。
     * 2. 只有该方法返回true时，stop(Runnable callback)或stop()方法才会被执行。
     */
    @Override
    public boolean isRunning() {
        // 默认返回false
        System.out.println("---SmartLifecycle--执行 isRunning 方法");
        return isRunning;
    }

    /**
     * 接口Lifecycle的子类的方法，只有非SmartLifecycle的子类才会执行该方法。<br/>
     * 1. 该方法只对直接实现接口Lifecycle的类才起作用，对实现SmartLifecycle接口的类无效。<br/>
     * 2. 方法stop()和方法stop(Runnable callback)的区别只在于，后者是SmartLifecycle子类的专属。
     */
    @Override
    public void stop() {
        System.out.println("---SmartLifecycle--执行 stop() 方法");
        isRunning = false;
    }


}
复制代码

6.实现ApplicationContextListener<ContextRefreshedEvent>，重写onApplicationEvent()方法
ApplicationContextListener 事件机制是观察者设计模式的实现，通过ApplicationEvent类和ApplicationListener接口，可以实现ApplicationContext事件处理；如果容器中存在 ApplicationListener 的Bean，当 ApplicationContext 调用 publishEvent 方法时，对应的Bean会被触发。publishEvent() 方法，同刚刚介绍的 Lifecycle 类似，也是在 finishRefresh() 方法中调用的。如下所示：

复制代码
protected void finishRefresh() {

    // Initialize lifecycle processor for this context.
    initLifecycleProcessor();

    // Propagate refresh to lifecycle processor first.
    getLifecycleProcessor().onRefresh();

    // Publish the final event.
    // 重点：事件机制发布(在下一种实现方式 ApplicationContextListener 中会涉及到)
    publishEvent(new ContextRefreshedEvent(this));

    // Participate in LiveBeansView MBean, if active.
    LiveBeansView.registerApplicationContext(this);
}
复制代码

其中 Spring 有一些内置的事件，当完成某种操作时会发出某些事件动作。比如监听ContextRefreshedEvent事件，当所有的bean都初始化完成并被成功装载后会触发该事件，实现ApplicationListener<ContextRefreshedEvent>接口可以收到监听动作，然后可以写自己的逻辑。同样事件我们可以自定义、监听也可以自定义，完全根据自己的业务逻辑来处理。

示例：(本例使用 Spring Boot框架)

复制代码
@Component
public class ApplicationListenerConfig implements ApplicationListener<ContextRefreshedEvent> {

    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        System.out.println("--ApplicationListener--监听到所有的bean都已经初始化完成");
    }

}
复制代码

附录：

  • 我们可以监听 ServletWebServerInitializedEvent 类，来监听 Servlet 是否初始化完成；
  • 也可以监听 ApplicationReadyEvent 类，来监听应用(项目)是否启动完成。

7.类实现ApplicationRunner，重写run()方法
在开发中可能会有这样的情景。需要在容器启动的时候执行一些内容。比如读取配置文件，数据库连接之类的。Spring 项目中，我们可以通过实现 ApplicationRunner接口，重写run() 方法。它的执行时机为容器启动完成的时候。
示例：(本例使用 Spring Boot框架)

复制代码
@Component
public class ApplicationRunnerConfig implements ApplicationRunner {

    @Override
    public void run(ApplicationArguments args) throws Exception {
        System.out.println("--ApplicationRunner---当前项目已经启动完成");
    }   

}
复制代码

8.类实现CommandLineRunner，重写run()方法
SpringBoot 中额外给我们提供了一个接口，这个接口是 CommandLineRunner。它和 ApplicationRunner功能一样，也都需要重写run()方法。该接口也是在容器启动完成的时候执行。
它们的不同之处在于：(其它使用都相同)
ApplicationRunner 可以在 Spring、SpringBoot 项目中使用；CommandLineRunner 只能在 Spring Boot 中使用
ApplicationRunner 中 run() 方法的参数为 ApplicationArguments，而 CommandLineRunner 中 run() 方法的参数为 String数组。
示例：(本例使用 Spring Boot框架)

复制代码
@Component
public class CommandLineRunnerConfig implements CommandLineRunner {

    @Override
    public void run(String... args) throws Exception {
        System.out.println("--CommandLineRunner---当前项目已经启动完成");
    }

}
复制代码

总结：执行顺序还是按照1、2、3、4、5、6、7、8的顺序进行加载的，每个实现都有不同的方式和不同的目的，同时需要了解每个实现的原理是什么，什么场景的时候使用。

posted @   郭慕荣  阅读(1672)  评论(0)  编辑  收藏  举报
相关博文：
·  spring 单例bean和多实例bean的总结
·  Spring系列之事件机制详解
·  Spring源码-IOC容器初始化过程【2】
·  Spring基础
·  Spring Ioc源码分析系列--Ioc容器注册BeanPostProcessor后置处理器以及事件消息处理
阅读排行：
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· Manus的开源复刻OpenManus初探
· AI 智能体引爆开源社区「GitHub 热点速览」
· 从HTTP原因短语缺失研究HTTP/2和HTTP/3的设计差异
· 三行代码完成国际化适配，妙~啊~
点击右上角即可分享
微信分享提示
SQL AI 助手