Spring Boot 启动时执行特定代码的完整指南

Spring Boot 提供了多种灵活的方式在应用启动时执行初始化代码，以下是所有可行方法的详细说明和最佳实践。

一、应用生命周期回调方式

1. CommandLineRunner 接口

@Component
@Order(1) // 可选，定义执行顺序
public class DatabaseInitializer implements CommandLineRunner {
    
    private final UserRepository userRepository;
    
    public DatabaseInitializer(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    
    @Override
    public void run(String... args) throws Exception {
        // 初始化数据库数据
        userRepository.save(new User("admin", "admin@example.com"));
        System.out.println("数据库初始化完成");
    }
}

特点：

• 在所有ApplicationReadyEvent之前执行
• 可以访问命令行参数
• 支持多实例，通过@Order控制顺序

2. ApplicationRunner 接口

@Component
@Order(2)
public class CacheWarmup implements ApplicationRunner {
    
    @Override
    public void run(ApplicationArguments args) throws Exception {
        // 更丰富的参数访问方式
        System.out.println("源参数: " + args.getSourceArgs());
        System.out.println("选项参数: " + args.getOptionNames());
        
        // 预热缓存逻辑
        System.out.println("缓存预热完成");
    }
}

与CommandLineRunner区别：

• 提供更结构化的参数访问(ApplicationArguments)
• 同样支持@Order排序

二、Spring事件监听方式

1. 监听特定生命周期事件

@Component
public class StartupEventListener {
    
    // 在环境准备完成后执行
    @EventListener(ApplicationEnvironmentPreparedEvent.class)
    public void handleEnvPrepared(ApplicationEnvironmentPreparedEvent event) {
        ConfigurableEnvironment env = event.getEnvironment();
        System.out.println("当前环境: " + env.getActiveProfiles());
    }
    
    // 在应用上下文准备好后执行
    @EventListener(ApplicationContextInitializedEvent.class)
    public void handleContextInit(ApplicationContextInitializedEvent event) {
        System.out.println("应用上下文初始化完成");
    }
    
    // 在所有Bean加载完成后执行
    @EventListener(ContextRefreshedEvent.class)
    public void handleContextRefresh(ContextRefreshedEvent event) {
        System.out.println("所有Bean已加载");
    }
    
    // 在应用完全启动后执行(推荐)
    @EventListener(ApplicationReadyEvent.class)
    public void handleAppReady(ApplicationReadyEvent event) {
        System.out.println("应用已完全启动，可以开始处理请求");
    }
}

2. 事件执行顺序

三、Bean生命周期回调

1. @PostConstruct 注解

@Service
public class SystemValidator {
    
    @Autowired
    private HealthCheckService healthCheckService;
    
    @PostConstruct
    public void validateSystem() {
        if (!healthCheckService.isDatabaseConnected()) {
            throw new IllegalStateException("数据库连接失败");
        }
        System.out.println("系统验证通过");
    }
}

特点：

• 在Bean依赖注入完成后立即执行
• 适用于单个Bean的初始化
• 抛出异常会阻止应用启动

2. InitializingBean 接口

@Component
public class NetworkChecker implements InitializingBean {
    
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("网络连接检查完成");
        // 执行网络检查逻辑
    }
}

与@PostConstruct比较：

• 功能类似，但属于Spring接口而非JSR-250标准
• 执行时机稍晚于@PostConstruct

四、Spring Boot特性扩展

1. ApplicationContextInitializer

public class CustomInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
    
    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        // 在上下文刷新前执行
        System.out.println("应用上下文初始化器执行");
        // 可以修改环境配置
        applicationContext.getEnvironment().setActiveProfiles("dev");
    }
}

注册方式：

1. 在META-INF/spring.factories中添加：

   org.springframework.context.ApplicationContextInitializer=com.example.CustomInitializer
   

2. 或通过SpringApplication添加：

   @SpringBootApplication
   public class MyApp {
       public static void main(String[] args) {
           SpringApplication app = new SpringApplication(MyApp.class);
           app.addInitializers(new CustomInitializer());
           app.run(args);
       }
   }
   

2. SpringApplicationRunListener

public class StartupMonitor implements SpringApplicationRunListener {
    
    public StartupMonitor(SpringApplication app, String[] args) {}
    
    @Override
    public void starting(ConfigurableBootstrapContext bootstrapContext) {
        System.out.println("应用开始启动");
    }
    
    @Override
    public void environmentPrepared(ConfigurableBootstrapContext bootstrapContext, 
                                  ConfigurableEnvironment environment) {
        System.out.println("环境准备完成");
    }
    
    // 其他生命周期方法...
}

注册方式：
在META-INF/spring.factories中：

org.springframework.boot.SpringApplicationRunListener=com.example.StartupMonitor

五、条件化初始化

1. 基于Profile的初始化

@Profile("dev")
@Component
public class DevDataLoader implements CommandLineRunner {
    
    @Override
    public void run(String... args) {
        System.out.println("加载开发环境测试数据");
    }
}

2. 基于条件的Bean创建

@Configuration
public class ConditionalInitConfig {
    
    @Bean
    @ConditionalOnProperty(name = "app.init-sample-data", havingValue = "true")
    public CommandLineRunner sampleDataLoader() {
        return args -> System.out.println("加载示例数据");
    }
}

六、初始化方法对比

方法	执行时机	适用场景	顺序控制	访问Spring上下文
ApplicationContextInitializer	最早阶段	环境准备	无	有限访问
@PostConstruct	Bean初始化	单个Bean初始化	无	完全访问
ApplicationRunner	启动中期	通用初始化	支持	完全访问
CommandLineRunner	启动中期	命令行相关初始化	支持	完全访问
ApplicationReadyEvent	最后阶段	安全的后启动操作	无	完全访问

七、最佳实践建议

1. 简单初始化：使用@PostConstruct或InitializingBean
2. 复杂初始化：使用CommandLineRunner/ApplicationRunner
3. 环境准备阶段：使用ApplicationContextInitializer
4. 完全启动后操作：监听ApplicationReadyEvent
5. 避免事项：
   • 不要在启动时执行长时间阻塞操作
   • 谨慎处理ContextRefreshedEvent(可能被触发多次)
   • 确保初始化代码是幂等的

八、高级应用示例

1. 异步初始化

@Component
public class AsyncInitializer {
    
    @EventListener(ApplicationReadyEvent.class)
    @Async
    public void asyncInit() {
        System.out.println("异步初始化开始");
        // 执行耗时初始化任务
        System.out.println("异步初始化完成");
    }
}

@Configuration
@EnableAsync
public class AsyncConfig {
    @Bean
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(2);
        executor.setMaxPoolSize(5);
        executor.setQueueCapacity(100);
        executor.initialize();
        return executor;
    }
}

2. 初始化失败处理

@Component
public class StartupFailureHandler implements ApplicationListener<ApplicationFailedEvent> {
    
    @Override
    public void onApplicationEvent(ApplicationFailedEvent event) {
        Throwable exception = event.getException();
        System.err.println("应用启动失败: " + exception.getMessage());
        // 发送警报或记录日志
    }
}

3. 多模块初始化协调

public interface StartupTask {
    void execute() throws Exception;
    int getOrder();
}

@Component
public class StartupCoordinator implements ApplicationRunner {
    
    @Autowired
    private List<StartupTask> startupTasks;
    
    @Override
    public void run(ApplicationArguments args) throws Exception {
        startupTasks.stream()
            .sorted(Comparator.comparingInt(StartupTask::getOrder))
            .forEach(task -> {
                try {
                    task.execute();
                } catch (Exception e) {
                    throw new StartupException("启动任务执行失败: " + task.getClass().getName(), e);
                }
            });
    }
}

通过以上多种方式，Spring Boot 提供了非常灵活的启动时初始化机制，开发者可以根据具体需求选择最适合的方法来实现启动时逻辑执行。