Spring启动生命周期

Spring Boot 生命周期详解
Spring Boot 应用程序的生命周期包含几个阶段，每个阶段都有特定的事件和钩子，允许开发者在应用程序的不同生命周期阶段插入自定义逻辑。以下是 Spring Boot 生命周期的主要阶段和对应的事件：

1. 准备阶段：
   1.1 ApplicationContextInitializer：

import org.springframework.context.ApplicationContextInitializer;
import org.springframework.context.ConfigurableApplicationContext;

public class MyApplicationContextInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        // 在应用上下文初始化之前执行的逻辑
        // 访问资源：可以访问 ConfigurableApplicationContext，但注意此时应用上下文中的 bean 尚未加载。
        // 推荐用途：适合做一些全局性的初始化工作，例如设置环境属性或配置文件的默认值。
    }
}

1.2 ApplicationEnvironmentPreparedEvent：

import org.springframework.boot.context.event.ApplicationEnvironmentPreparedEvent;
import org.springframework.context.ApplicationListener;

public class MyApplicationEnvironmentPreparedListener implements ApplicationListener<ApplicationEnvironmentPreparedEvent> {
    @Override
    public void onApplicationEvent(ApplicationEnvironmentPreparedEvent event) {
        // 在应用环境准备完成之前执行的逻辑
        // 访问资源：通过事件对象可以访问到 ConfigurableEnvironment，在该阶段，应用上下文还未创建。
        // 推荐用途：在应用环境准备完成之前进行一些自定义配置，例如修改配置属性。
    }
}

2. 启动阶段：
   2.1 ApplicationStartedEvent：

import org.springframework.boot.context.event.ApplicationStartedEvent;
import org.springframework.context.ApplicationListener;

public class MyApplicationStartedListener implements ApplicationListener<ApplicationStartedEvent> {
    @Override
    public void onApplicationEvent(ApplicationStartedEvent event) {
        // 在 `SpringApplication` 开始运行时触发
        // 访问资源：无法直接访问太多资源，主要用于监听应用启动的事件。
        // 推荐用途：适合在应用程序启动后执行一些简单的逻辑，监听启动事件。
        // 具体场景：可以用于执行一些与应用程序整体启动相关的逻辑，例如记录应用程序启动时间等。
    }
}

2.2 ApplicationRunner：

import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;

public class MyApplicationRunner implements ApplicationRunner {
    @Override
    public void run(ApplicationArguments args) throws Exception {
        // 在 Spring Boot 应用程序启动后执行逻辑
        // 访问资源：可以访问 `ApplicationArguments`，获取应用启动时的参数。
        // 推荐用途：适合在应用程序启动后执行一些高级的逻辑，处理应用启动参数。
        // 具体场景：可用于处理命令行参数，执行与应用启动有关的高级逻辑，例如数据初始化等。
    }
}

3. 初始化阶段：
   3.1 ApplicationContextRefreshedEvent：

import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.context.ApplicationListener;

public class MyContextRefreshedListener implements ApplicationListener<ContextRefreshedEvent> {
    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        // 在容器刷新完成后执行自定义逻辑
        // 访问资源：可以访问到 `ConfigurableApplicationContext`，表示应用上下文已刷新。
        // 推荐用途：适合在容器刷新完成后执行一些初始化操作，处理一些全局性的逻辑。
        // 具体场景：可以用于执行一些在整个应用上下文刷新完成后需要进行的初始化操作，例如加载缓存等。
    }
}

3.2 InitializingBean：

import org.springframework.beans.factory.InitializingBean;

public class MyBean implements InitializingBean {
    @Override
    public void afterPropertiesSet() throws Exception {
        // 初始化逻辑
        // 访问资源：可以在 `afterPropertiesSet` 方法中访问到 `BeanFactory`，但依赖于 bean 的属性注入。
        // 推荐用途：适合在 bean 初始化阶段执行一些初始化逻辑，处理 bean 特定的初始化操作。
        // 具体场景：用于在 bean 的属性注入完成后执行一些与该 bean 初始化相关的操作，例如数据库连接的初始化等。
    }
}

3.3 @PostConstruct：

import javax.annotation.PostConstruct;

public class MyBeanWithPostConstruct {
    @PostConstruct
    public void postConstruct() {
        // 在对象创建并且所有依赖注入完成后执行的逻辑
        // 访问资源：可以在标注有 `@PostConstruct` 的方法中访问 bean 的所有资源，但依赖于 bean 的属性注入。
        // 推荐用途：适合在 bean 初始化阶段执行一些初始化逻辑，处理 bean 特定的初始化操作。
        // 具体场景：可用于执行一些在 bean 初始化时需要进行的操作，例如初始化配置等。
    }
}

4. 销毁阶段：
   4.1 DisposableBean：

import org.springframework.beans.factory.DisposableBean;

public class MyDisposableBean implements DisposableBean {
    @Override
    public void destroy() throws Exception {
        // 在容器销毁时执行的逻辑
        // 访问资源：可以在 `destroy` 方法中访问到 `BeanFactory`，但依赖于 bean 的属性注入。
        // 推荐用途：适合在容器销毁时执行一些清理逻辑，处理 bean 特定的销毁操作。
        // 具体场景：用于在 bean 被销毁时执行一些与该 bean 相关的清理操作，例如关闭数据库连接等。
    }
}

4.2 @PreDestroy：

import javax.annotation.PreDestroy;

public class MyBeanWithPreDestroy {
    @PreDestroy
    public void preDestroy() {
        // 在对象销毁前执行的逻辑
        // 访问资源：可以在标注有 `@PreDestroy` 的方法中访问 bean 的所有资源，但依赖于 bean 的属性注入。
        // 推荐用途：适合在 bean 销毁前执行一些清理逻辑，处理 bean 特定的销毁操作。
        // 具体场景：可用于执行一些在 bean 销毁前需要进行的清理操作，例如释放资源等。
    }
}

4.3 DestructionAwareBeanPostProcessor：

import org.springframework.beans.factory.config.DestructionAwareBeanPostProcessor;

public class MyDestructionAwareBeanPostProcessor implements DestructionAwareBeanPostProcessor {
    @Override
    public void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException {
        // 在 bean 销毁前执行的逻辑
        // 访问资源：可以在 `postProcessBeforeDestruction` 方法中访问到 bean 对象和 bean 的名称。
        // 推荐用途：适合在 bean 销毁前执行一些自定义的清理逻辑，处理 bean 特定的销毁操作。
        // 具体场景：用于在 bean 销毁前执行一些与该 bean 相关的自定义清理操作，例如发送通知等。
    }
}

5. 其他：
   5.1 ApplicationFailedEvent：

import org.springframework.boot.context.event.ApplicationFailedEvent;
import org.springframework.context.ApplicationListener;

public class MyApplicationFailedListener implements ApplicationListener<ApplicationFailedEvent> {
    @Override
    public void onApplicationEvent(ApplicationFailedEvent event) {
        // 在启动时发生异常时执行的逻辑
        // 访问资源：可以访问到异常信息，但不能保证所有的资源都已经初始化完成。
        // 推荐用途：适合在应用程序启动失败时执行一些额外的逻辑，例如记录错误信息或发送通知。
    }
}

5.2 ApplicationReadyEvent：

import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.context.ApplicationListener;

public class MyApplicationReadyListener implements ApplicationListener<ApplicationReadyEvent> {
    @Override
    public void onApplicationEvent(ApplicationReadyEvent event) {
        // 在应用程序准备就绪时执行的逻辑
        // 访问资源：可以访问到应用上下文已经准备就绪的状态。
        // 推荐用途：适合执行在应用程序准备就绪后需要进行的逻辑，例如启动定时任务等。
    }
}