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

@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("数据库初始化完成");
    }
}

@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("缓存预热完成");
    }
}

@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("应用已完全启动，可以开始处理请求");
    }
}

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

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

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

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

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

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("环境准备完成");
    }
    
    // 其他生命周期方法...
}

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

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

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

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

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

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