SpringBoot启动时自动执行特定代码的完整指南

目录

• 一、应用生命周期回调方式
• 1. CommandLineRunner 接口
• 2. ApplicationRunner 接口
• 二、Spring事件监听方式
• 1. 监听特定生命周期事件
• 2. 事件执行顺序
• 三、Bean生命周期回调
• 1. @PostConstruct 注解
• 2. InitializingBean 接口
• 四、Spring Boot特性扩展
• 1. ApplicationContextInitializer
• 2. SpringApplicationRunListener
• 五、条件化初始化
• 1. 基于Profile的初始化
• 2. 基于条件的Bean创建
• 六、初始化方法对比
• 七、最佳实践建议
• 八、高级应用示例
• 1. 异步初始化
• 2. 初始化失败处理
• 3. 多模块初始化协调

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

1. CommandLineRunner 接口

@Component
@Order(1) // 可选，定义执行顺序
public class DatabaseInitializer implements CommandLineRunner {
    
    private final UserRepository userRepository;
    
    public Databa编程seInitializer(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(ApplicationReadyEventphp 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. ApplicRtqdBlPationContextInitializer

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

注册方式：

1.在META-INF/sprinpythong.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("加载示例数据");
    }
}

六、初始化方法对比

七、最佳实践建议

• 简单初始化：使用@PostConstruct或InitializingBean
• 复杂初始化：使用CommandLineRunner/ApplicationRunner
• 环境准备阶段：使用ApplicationContextInitializer
• 完全启动后操作：监听ApplicationReadyEvent

避免事项：

• 不要在启动时执行长时间阻塞操作
• 谨慎处理ContextRefreshedEvent(可能被触发多次)
• 确保初始化代码是幂等的

八、高级应用示例

1. 异步初始化

@Component
public class AsyncInitializer {
    
    @EventListener(ApplicationReadyEvent.class)
    javascript@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 提供了非常灵活的启动时初始化机制，开发者可以根据具体需求选择最适合的方法来实现启动时逻辑执行。

以上就是SpringBoot启动时自动执行特定代码的完整指南的详细内容，更多关于SpringBoot执行特定代码的资料请关注编程客栈(www.devze.com)其它相关文章！