SpringBoot启动时执行特定代码的10种方式

@Component
public class PostConstructExample {
    
    private static final Logger logger = LoggerFactory.getLogger(PostConstructExample.class);
    
    @PostConstruct
    public void init() {
        logger.info("@PostConstruct方法执行 - 开始初始化工作");
        
        // 执行初始化逻辑
        initializeCache();
        loadConfiguration();
        validateEnvironment();
        
        logger.info("@PostConstruct方法执行 - 初始化完成");
    }
    
    private void initializeCache() {
        logger.info("初始化缓存数据...");
        // 模拟缓存预热
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
    
    private void loadConfiguration() {
        logger.info("加载配置文件...");
        // 模拟配置加载
    }
    
    private void validateEnvironment() {
        logger.info("验证环境配置...");
        // 模拟环境验证
    }
}

@Component
public class InitializingBeanExample implements InitializingBean {
    
    private static final Logger logger = LoggerFactory.getLogger(InitializingBeanExample.class);
    
    private final Environment environment;
    private String appName;
    private String appVersion;
    
    public InitializingBeanExample(Environment environment) {
        this.environment = environment;
    }
    
    @Override
    public void afterPropertiesSet() throws Exception {
        logger.info("InitializingBean.afterPropertiesSet()方法执行");
        
        // 获取配置信息
        this.appName = environment.getProperty("spring.application.name", "unknown");
        this.appVersion = environment.getProperty("app.version", "1.0.0");
        
        // 执行初始化逻辑
        initializeApplication();
        setupGlobalVariables();
        
        logger.info("应用初始化完成: {} v{}", appName, appVersion);
    }
    
    private void initializeApplication() {
        logger.info("初始化应用核心组件...");
        // 模拟核心组件初始化
    }
    
    private void setupGlobalVariables() {
        logger.info("设置全局变量...");
        // 模拟全局变量设置
    }
    
    public String getAppInfo() {
        return String.format("%s v%s", appName, appVersion);
    }
}

@Component
public class ExecutionOrderExample implements InitializingBean {
    
    @PostConstruct
    public void postConstruct() {
        System.out.println("1. @PostConstruct 执行");
    }
    
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("2. InitializingBean.afterPropertiesSet() 执行");
    }
    
    @Bean(initMethod = "initMethod")
    public DemoBean demoBean() {
        return new DemoBean();
    }
    
    public static class DemoBean {
        public void initMethod() {
            System.out.println("3. @Bean initMethod 执行");
        }
    }
}

@Configuration
public class InitMethodConfig {
    
    private static final Logger logger = LoggerFactory.getLogger(InitMethodConfig.class);
    
    @Bean(initMethod = "initialize", destroyMethod = "cleanup")
    public DatabaseConnection databaseConnection() {
        logger.info("创建DatabaseConnection Bean实例");
        return new DatabaseConnection();
    }
    
    public static class DatabaseConnection {
        
        public void initialize() {
            logger.info("DatabaseConnection initMethod执行 - 建立数据库连接");
            // 模拟数据库连接建立
            try {
                Thread.sleep(2000);
                logger.info("数据库连接建立成功");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                logger.error("数据库连接建立失败", e);
            }
        }
        
        public void cleanup() {
            logger.info("DatabaseConnection destroyMethod执行 - 关闭数据库连接");
            // 模拟资源清理
        }
        
        public void query(String sql) {
            logger.info("执行查询: {}", sql);
        }
    }
}

@Configuration
public class ComplexInitMethodExample {
    
    @Bean(initMethod = "start", destroyMethod = "stop")
    public MessageQueueConsumer messageQueueConsumer() {
        return new MessageQueueConsumer();
    }
    
    @Bean(initMethod = "initializeConnectionPool")
    public ConnectionPool connectionPool() {
        return new ConnectionPool();
    }
    
    public static class MessageQueueConsumer {
        public void start() {
            System.out.println("消息队列消费者启动...");
            // 模拟启动逻辑
        }
        
        public void stop() {
            System.out.println("消息队列消费者停止...");
            // 模拟停止逻辑
        }
    }
    
    public static class ConnectionPool {
        public void initializeConnectionPool() {
            System.out.println("初始化数据库连接池...");
            // 模拟连接池初始化
        }
    }
}

@Component
@Order(1)
public class PrimaryApplicationRunner implements ApplicationRunner {
    
    private static final Logger logger = LoggerFactory.getLogger(PrimaryApplicationRunner.class);
    
    private final Environment environment;
    private final UserRepository userRepository;
    
    public PrimaryApplicationRunner(Environment environment, UserRepository userRepository) {
        this.environment = environment;
        this.userRepository = userRepository;
    }
    
    @Override
    public void run(ApplicationArguments args) throws Exception {
        logger.info("PrimaryApplicationRunner开始执行 - 应用启动完成");
        
        // 获取启动参数
        logger.info("启动参数: {}", Arrays.toString(args.getSourceArgs()));
        logger.info("非选项参数: {}", args.getNonOptionArgs());
        logger.info("选项参数名称: {}", args.getOptionNames());
        
        // 执行核心初始化逻辑
        initializeSystem();
        preloadData();
        startBackgroundServices();
        
        logger.info("PrimaryApplicationRunner执行完成");
    }
    
    private void initializeSystem() {
        logger.info("初始化系统核心组件...");
        
        // 检查数据库连接
        checkDatabaseConnection();
        
        // 验证必要的配置
        validateRequiredConfigurations();
        
        // 初始化系统缓存
        initializeSystemCache();
    }
    
    private void checkDatabaseConnection() {
        try {
            long userCount = userRepository.count();
            logger.info("数据库连接正常，用户数量: {}", userCount);
        } catch (Exception e) {
            logger.error("数据库连接检查失败", e);
            throw new RuntimeException("数据库连接失败", e);
        }
    }
    
    private void validateRequiredConfigurations() {
        String[] requiredProps = {
            "spring.datasource.url",
            "spring.redis.host",
            "app.security.secret-key"
        };
        
        for (String prop : requiredProps) {
            if (!environment.containsProperty(prop)) {
                throw new IllegalStateException("必要的配置项缺失: " + prop);
            }
        }
        logger.info("所有必要配置项验证通过");
    }
    
    private void initializeSystemCache() {
        logger.info("初始化系统缓存...");
        // 模拟缓存初始化
    }
    
    private void preloadData() {
        logger.info("预加载热点数据...");
        // 模拟数据预加载
    }
    
    private void startBackgroundServices() {
        logger.info("启动后台服务...");
        // 模拟后台服务启动
    }
}

@Component
@Order(1)
public class FirstApplicationRunner implements ApplicationRunner {
    
    @Override
    public void run(ApplicationArguments args) throws Exception {
        System.out.println("第一个ApplicationRunner执行 - Order(1)");
        // 执行最高优先级的初始化任务
    }
}

@Component  
@Order(2)
public class SecondApplicationRunner implements ApplicationRunner {
    
    @Override
    public void run(ApplicationArguments args) throws Exception {
        System.out.println("第二个ApplicationRunner执行 - Order(2)");
        // 执行次优先级的初始化任务
    }
}

@Component
@Order(3)
public class ThirdApplicationRunner implements ApplicationRunner {
    
    @Override
    public void run(ApplicationArguments args) throws Exception {
        System.out.println("第三个ApplicationRunner执行 - Order(3)");
        // 执行最低优先级的初始化任务
    }
}

@Component
@Order(2)
public class CommandLineRunnerExample implements CommandLineRunner {
    
    private static final Logger logger = LoggerFactory.getLogger(CommandLineRunnerExample.class);
    
    private final DataSource dataSource;
    private final RedisTemplate<String, Object> redisTemplate;
    
    public CommandLineRunnerExample(DataSource dataSource, RedisTemplate<String, Object> redisTemplate) {
        this.dataSource = dataSource;
        this.redisTemplate = redisTemplate;
    }
    
    @Override
    public void run(String... args) throws Exception {
        logger.info("CommandLineRunner开始执行 - 参数数量: {}", args.length);
        
        // 输出所有命令行参数
        for (int i = 0; i < args.length; i++) {
            logger.info("参数 {}: {}", i, args[i]);
        }
        
        // 执行数据源相关的初始化
        initializeDataSource();
        
        // 执行缓存相关的初始化
        initializeCache();
        
        // 执行其他初始化任务
        performSanityChecks();
        
        logger.info("CommandLineRunner执行完成");
    }
    
    private void initializeDataSource() {
        logger.info("初始化数据源...");
        try {
            // 测试数据库连接
            try (Connection connection = dataSource.getConnection()) {
                DatabaseMetaData metaData = connection.getMetaData();
                logger.info("数据库连接成功: {} {}", 
                    metaData.getDatabaseProductName(), 
                    metaData.getDatabaseProductVersion());
            }
        } catch (SQLException e) {
            logger.error("数据源初始化失败", e);
            throw new RuntimeException("数据源初始化失败", e);
        }
    }
    
    private void initializeCache() {
        logger.info("初始化缓存...");
        try {
            // 测试Redis连接
            redisTemplate.opsForValue().set("startup-test", "success", Duration.ofSeconds(30));
            String result = (String) redisTemplate.opsForValue().get("startup-test");
            logger.info("Redis连接测试: {}", "success".equals(result) ? "成功" : "失败");
        } catch (Exception e) {
            logger.error("缓存初始化失败", e);
            throw new RuntimeException("缓存初始化失败", e);
        }
    }
    
    private void performSanityChecks() {
        logger.info("执行系统健康检查...");
        // 模拟系统检查
        checkDiskSpace();
        checkMemoryUsage();
    }
    
    private void checkDiskSpace() {
        logger.info("检查磁盘空间...");
        // 模拟磁盘空间检查
    }
    
    private void checkMemoryUsage() {
        logger.info("检查内存使用情况...");
        // 模拟内存检查
    }
}

@Component
public class ContextRefreshedEventListener {
    
    private static final Logger logger = LoggerFactory.getLogger(ContextRefreshedEventListener.class);
    
    private final ApplicationContext applicationContext;
    private final SystemConfigService systemConfigService;
    
    public ContextRefreshedEventListener(ApplicationContext applicationContext, 
                                       SystemConfigService systemConfigService) {
        this.applicationContext = applicationContext;
        this.systemConfigService = systemConfigService;
    }
    
    @EventListener(ContextRefreshedEvent.class)
    public void onContextRefreshed(ContextRefreshedEvent event) {
        // 避免在子容器中重复执行
        if (event.getApplicationContext().getParent() != null) {
            return;
        }
        
        logger.info("ContextRefreshedEvent事件触发 - Spring容器刷新完成");
        
        // 执行初始化逻辑
        loadSystemConfigurations();
        initializeThirdPartyServices();
        registerSystemBeans();
        
        logger.info("ContextRefreshedEvent事件处理完成");
    }
    
    private void loadSystemConfigurations() {
        logger.info("加载系统配置...");
        
        try {
            // 从数据库加载系统配置
            Map<String, String> configs = systemConfigService.loadAllConfigs();
            logger.info("加载了 {} 条系统配置", configs.size());
            
            // 将配置设置到应用上下文中
            configs.forEach((key, value) -> {
                logger.debug("系统配置: {} = {}", key, value);
            });
            
        } catch (Exception e) {
            logger.error("系统配置加载失败", e);
            throw new RuntimeException("系统配置加载失败", e);
        }
    }
    
    private void initializeThirdPartyServices() {
        logger.info("初始化第三方服务...");
        
        // 检查所有需要的Bean是否已正确初始化
        String[] requiredBeans = {
            "dataSource",
            "redisTemplate",
            "restTemplate"
        };
        
        for (String beanName : requiredBeans) {
            if (applicationContext.containsBean(beanName)) {
                Object bean = applicationContext.getBean(beanName);
                logger.info("Bean {} 初始化成功: {}", beanName, bean.getClass().getSimpleName());
            } else {
                logger.warn("Bean {} 未找到", beanName);
            }
        }
    }
    
    private void registerSystemBeans() {
        logger.info("注册系统Bean...");
        // 模拟系统Bean注册
    }
}

@Component
public class MultipleEventListeners {
    
    private static final Logger logger = LoggerFactory.getLogger(MultipleEventListeners.class);
    
    /**
     * 应用启动事件
     */
    @EventListener(ApplicationStartedEvent.class)
    public void onApplicationStarted(ApplicationStartedEvent event) {
        logger.info("应用程序启动完成 - ApplicationStartedEvent");
    }
    
    /**
     * 应用准备就绪事件
     */
    @EventListener(ApplicationReadyEvent.class)
    public void onApplicationReady(ApplicationReadyEvent event) {
        logger.info("应用程序准备就绪 - ApplicationReadyEvent");
        // 可以在这里执行一些需要在应用完全就绪后执行的任务
    }
    
    /**
     * 应用启动失败事件
     */
    @EventListener(ApplicationFailedEvent.class)
    public void onApplicationFailed(ApplicationFailedEvent event) {
        logger.error("应用程序启动失败 - ApplicationFailedEvent", event.getException());
        // 可以在这里执行清理操作或发送告警
    }
}

@Component
public class CustomApplicationListener implements ApplicationListener<ApplicationReadyEvent> {
    
    private static final Logger logger = LoggerFactory.getLogger(CustomApplicationListener.class);
    
    private final MetricService metricService;
    private final HealthCheckService healthCheckService;
    
    public CustomApplicationListener(MetricService metricService, 
                                   HealthCheckService healthCheckService) {
        this.metricService = metricService;
        this.healthCheckService = healthCheckService;
    }
    
    @Override
    public void onApplicationEvent(ApplicationReadyEvent event) {
        logger.info("ApplicationListener收到ApplicationReadyEvent - 开始执行启动任务");
        
        // 执行系统健康检查
        performHealthChecks();
        
        // 初始化监控指标
        initializeMetrics();
        
        // 启动后台监控任务
        startMonitoringTasks();
        
        logger.info("ApplicationListener启动任务执行完成");
    }
    
    private void performHealthChecks() {
        logger.info("执行系统健康检查...");
        
        try {
            HealthCheckResult result = healthCheckService.performComprehensiveCheck();
            
            if (result.isHealthy()) {
                logger.info("系统健康检查通过: {}", result.getMessage());
            } else {
                logger.error("系统健康检查失败: {}", result.getMessage());
                // 可以根据严重程度决定是否终止启动
                if (result.isCritical()) {
                    throw new RuntimeException("关键健康检查失败: " + result.getMessage());
                }
            }
        } catch (Exception e) {
            logger.error("健康检查执行异常", e);
            throw new RuntimeException("健康检查失败", e);
        }
    }
    
    private void initializeMetrics() {
        logger.info("初始化系统监控指标...");
        
        // 注册自定义指标
        metricService.registerCustomMetrics();
        
        // 初始化性能基准
        metricService.initializePerformanceBaselines();
        
        logger.info("监控指标初始化完成");
    }
    
    private void startMonitoringTasks() {
        logger.info("启动后台监控任务...");
        
        // 启动性能监控
        metricService.startPerformanceMonitoring();
        
        // 启动资源使用监控
        metricService.startResourceMonitoring();
        
        logger.info("后台监控任务启动完成");
    }
}

@Configuration
public class StaticBlockConfiguration {
    
    private static final Logger logger = LoggerFactory.getLogger(StaticBlockConfiguration.class);
    
    // 静态代码块 - 在类加载时执行
    static {
        logger.info("StaticBlockConfiguration类加载 - 静态代码块执行");
        
        // 执行一些类级别的初始化
        initializeNativeLibraries();
        setupSecurityProviders();
        configureLogging();
    }
    
    private static void initializeNativeLibraries() {
        logger.info("初始化本地库...");
        // 模拟本地库初始化
        try {
            // 加载本地库
            // System.loadLibrary("native-lib");
            logger.info("本地库初始化完成");
        } catch (Exception e) {
            logger.error("本地库初始化失败", e);
        }
    }
    
    private static void setupSecurityProviders() {
        logger.info("设置安全提供者...");
        // 模拟安全设置
    }
    
    private static void configureLogging() {
        logger.info("配置日志系统...");
        // 模拟日志配置
    }
    
    @Bean
    public SystemInitializer systemInitializer() {
        logger.info("创建SystemInitializer Bean");
        return new SystemInitializer();
    }
    
    public static class SystemInitializer {
        public SystemInitializer() {
            logger.info("SystemInitializer构造函数执行");
        }
    }
}

@Component
public class CustomSmartLifecycle implements SmartLifecycle {
    
    private static final Logger logger = LoggerFactory.getLogger(CustomSmartLifecycle.class);
    
    private volatile boolean running = false;
    private final TaskScheduler taskScheduler;
    private ScheduledFuture<?> scheduledTask;
    
    public CustomSmartLifecycle(TaskScheduler taskScheduler) {
        this.taskScheduler = taskScheduler;
    }
    
    @Override
    public void start() {
        logger.info("CustomSmartLifecycle开始启动");
        
        if (!running) {
            // 执行启动逻辑
            initializeServices();
            startBackgroundTasks();
            running = true;
            
            logger.info("CustomSmartLifecycle启动完成");
        }
    }
    
    @Override
    public void stop() {
        logger.info("CustomSmartLifecycle开始停止");
        
        if (running) {
            // 执行停止逻辑
            stopBackgroundTasks();
            cleanupResources();
            running = false;
            
            logger.info("CustomSmartLifecycle停止完成");
        }
    }
    
    @Override
    public boolean isRunning() {
        return running;
    }
    
    @Override
    public int getPhase() {
        // 返回一个相位值，控制启动和停止的顺序
        return 0;
    }
    
    @Override
    public boolean isAutoStartup() {
        return true;
    }
    
    private void initializeServices() {
        logger.info("初始化后台服务...");
        // 模拟服务初始化
    }
    
    private void startBackgroundTasks() {
        logger.info("启动后台任务...");
        
        // 启动定时任务
        scheduledTask = taskScheduler.scheduleAtFixedRate(() -> {
            logger.debug("执行后台任务...");
            // 模拟后台任务执行
        }, Duration.ofSeconds(30));
    }
    
    private void stopBackgroundTasks() {
        logger.info("停止后台任务...");
        
        if (scheduledTask != null && !scheduledTask.isCancelled()) {
            scheduledTask.cancel(true);
            logger.info("后台任务已停止");
        }
    }
    
    private void cleanupResources() {
        logger.info("清理资源...");
        // 模拟资源清理
    }
}

@Configuration
public class ConditionalInitializationConfig {
    
    private static final Logger logger = LoggerFactory.getLogger(ConditionalInitializationConfig.class);
    
    @Bean
    @ConditionalOnProperty(name = "app.feature.cache.enabled", havingValue = "true")
    public CacheInitializer cacheInitializer() {
        logger.info("创建CacheInitializer - 缓存功能已启用");
        return new CacheInitializer();
    }
    
    @Bean
    @ConditionalOnClass(name = "com.example.ExternalService")
    public ExternalServiceInitializer externalServiceInitializer() {
        logger.info("创建ExternalServiceInitializer - 检测到ExternalService类");
        return new ExternalServiceInitializer();
    }
    
    @Bean
    @ConditionalOnExpression("${app.mode:dev} == 'prod'")
    public ProductionInitializer productionInitializer() {
        logger.info("创建ProductionInitializer - 生产环境模式");
        return new ProductionInitializer();
    }
    
    @Bean
    @ConditionalOnWebApplication
    public WebApplicationInitializer webApplicationInitializer() {
        logger.info("创建WebApplicationInitializer - Web应用环境");
        return new WebApplicationInitializer();
    }
    
    public static class CacheInitializer {
        @PostConstruct
        public void init() {
            logger.info("初始化缓存系统...");
            // 模拟缓存初始化
        }
    }
    
    public static class ExternalServiceInitializer {
        @PostConstruct
        public void init() {
            logger.info("初始化外部服务...");
            // 模拟外部服务初始化
        }
    }
    
    public static class ProductionInitializer {
        @PostConstruct
        public void init() {
            logger.info("执行生产环境特定初始化...");
            // 生产环境特定的初始化逻辑
        }
    }
    
    public static class WebApplicationInitializer {
        @PostConstruct
        public void init() {
            logger.info("执行Web应用特定初始化...");
            // Web应用特定的初始化逻辑
        }
    }
}

graph TD
    A[Spring Boot应用启动] --> B[加载配置类静态代码块]
    B --> C[创建Bean实例]
    C --> D[依赖注入]
    D --> E[@PostConstruct方法]
    E --> F[InitializingBean.afterPropertiesSet]
    F --> G[@Bean initMethod]
    G --> H[ContextRefreshedEvent事件]
    H --> I[ApplicationRunner.run]
    I --> J[CommandLineRunner.run]
    J --> K[ApplicationReadyEvent事件]
    K --> L[应用完全就绪]
    
    style B fill:#e1f5fe
    style E fill:#f3e5f5
    style F fill:#e8f5e8
    style G fill:#fff3e0
    style I fill:#ffebee
    style J fill:#fce4ec

@Component
public class ExecutionOrderVerifier {
    
    // 1. 静态代码块（类加载时执行）
    static {
        System.out.println("1. 静态代码块执行");
    }
    
    public ExecutionOrderVerifier() {
        System.out.println("2. 构造函数执行");
    }
    
    @PostConstruct
    public void postConstruct() {
        System.out.println("3. @PostConstruct方法执行");
    }
}

@Component
public class ExecutionOrderVerifier2 implements InitializingBean {
    
    @PostConstruct
    public void postConstruct() {
        System.out.println("4. @PostConstruct方法执行（第二个Bean）");
    }
    
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("5. InitializingBean.afterPropertiesSet执行");
    }
}

@Configuration
public class ExecutionOrderConfig {
    
    @Bean(initMethod = "initMethod")
    public OrderDemoBean orderDemoBean() {
        System.out.println("6. @Bean方法执行 - 创建Bean实例");
        return new OrderDemoBean();
    }
    
    public static class OrderDemoBean {
        public void initMethod() {
            System.out.println("7. @Bean initMethod执行");
        }
    }
}

@Component
@Order(1)
public class OrderApplicationRunner implements ApplicationRunner {
    @Override
    public void run(ApplicationArguments args) throws Exception {
        System.out.println("8. ApplicationRunner执行 - Order(1)");
    }
}

@Component  
@Order(2)
public class OrderCommandLineRunner implements CommandLineRunner {
    @Override
    public void run(String... args) throws Exception {
        System.out.println("9. CommandLineRunner执行 - Order(2)");
    }
}

@Component
public class OrderEventListener {
    
    @EventListener(ContextRefreshedEvent.class)
    public void onContextRefreshed(ContextRefreshedEvent event) {
        System.out.println("10. ContextRefreshedEvent事件处理");
    }
    
    @EventListener(ApplicationReadyEvent.class)
    public void onApplicationReady(ApplicationReadyEvent event) {
        System.out.println("11. ApplicationReadyEvent事件处理 - 应用完全就绪");
    }
}

@Component
@Order(1)
public class SystemInitializer implements ApplicationRunner {
    
    private static final Logger logger = LoggerFactory.getLogger(SystemInitializer.class);
    
    private final ApplicationContext applicationContext;
    private final DataSource dataSource;
    private final RedisTemplate<String, Object> redisTemplate;
    private final SystemConfigRepository configRepository;
    
    public SystemInitializer(ApplicationContext applicationContext,
                           DataSource dataSource,
                           RedisTemplate<String, Object> redisTemplate,
                           SystemConfigRepository configRepository) {
        this.applicationContext = applicationContext;
        this.dataSource = dataSource;
        this.redisTemplate = redisTemplate;
        this.configRepository = configRepository;
    }
    
    @Override
    public void run(ApplicationArguments args) throws Exception {
        logger.info("====== 系统初始化开始 ======");
        
        // 阶段1: 基础设施检查
        checkInfrastructure();
        
        // 阶段2: 数据初始化
        initializeData();
        
        // 阶段3: 缓存预热
        warmUpCaches();
        
        // 阶段4: 服务启动
        startServices();
        
        logger.info("====== 系统初始化完成 ======");
    }
    
    private void checkInfrastructure() {
        logger.info("阶段1: 检查基础设施...");
        
        // 检查数据库
        checkDatabase();
        
        // 检查Redis
        checkRedis();
        
        // 检查磁盘空间
        checkDiskSpace();
        
        logger.info("基础设施检查完成");
    }
    
    private void checkDatabase() {
        try (Connection connection = dataSource.getConnection()) {
            DatabaseMetaData metaData = connection.getMetaData();
            String dbName = metaData.getDatabaseProductName();
            String version = metaData.getDatabaseProductVersion();
            logger.info("数据库连接正常: {} {}", dbName, version);
            
            // 检查必要的表是否存在
            checkRequiredTables(connection);
            
        } catch (SQLException e) {
            logger.error("数据库检查失败", e);
            throw new RuntimeException("数据库不可用", e);
        }
    }
    
    private void checkRequiredTables(Connection connection) throws SQLException {
        String[] requiredTables = {"users", "system_config", "audit_log"};
        DatabaseMetaData metaData = connection.getMetaData();
        
        for (String table : requiredTables) {
            try (ResultSet rs = metaData.getTables(null, null, table, null)) {
                if (!rs.next()) {
                    throw new RuntimeException("必要的表不存在: " + table);
                }
            }
        }
        logger.info("所有必要的表都存在");
    }
    
    private void checkRedis() {
        try {
            redisTemplate.opsForValue().set("health-check", "ok", Duration.ofSeconds(10));
            String result = (String) redisTemplate.opsForValue().get("health-check");
            if ("ok".equals(result)) {
                logger.info("Redis连接正常");
            } else {
                throw new RuntimeException("Redis响应异常");
            }
        } catch (Exception e) {
            logger.error("Redis检查失败", e);
            throw new RuntimeException("Redis不可用", e);
        }
    }
    
    private void checkDiskSpace() {
        File root = new File("/");
        long freeSpace = root.getFreeSpace();
        long totalSpace = root.getTotalSpace();
        double freePercent = (double) freeSpace / totalSpace * 100;
        
        logger.info("磁盘空间: {}/{} GB ({:.2f}% 空闲)",
            (totalSpace - freeSpace) / (1024 * 1024 * 1024),
            totalSpace / (1024 * 1024 * 1024),
            freePercent);
            
        if (freePercent < 10.0) {
            logger.warn("磁盘空间不足，空闲空间低于10%");
        }
    }
    
    private void initializeData() {
        logger.info("阶段2: 初始化数据...");
        
        // 加载系统配置
        loadSystemConfigs();
        
        // 初始化基础数据
        initializeBaseData();
        
        logger.info("数据初始化完成");
    }
    
    private void loadSystemConfigs() {
        try {
            List<SystemConfig> configs = configRepository.findAll();
            logger.info("加载了 {} 条系统配置", configs.size());
            
            // 将配置加载到内存或缓存中
            configs.forEach(config -> {
                logger.debug("系统配置: {} = {}", config.getKey(), config.getValue());
            });
            
        } catch (Exception e) {
            logger.error("系统配置加载失败", e);
            throw new RuntimeException("系统配置加载失败", e);
        }
    }
    
    private void initializeBaseData() {
        logger.info("初始化基础数据...");
        // 模拟基础数据初始化
        // 如：默认用户、角色、权限等
    }
    
    private void warmUpCaches() {
        logger.info("阶段3: 缓存预热...");
        
        // 预热用户缓存
        warmUpUserCache();
        
        // 预热配置缓存
        warmUpConfigCache();
        
        logger.info("缓存预热完成");
    }
    
    private void warmUpUserCache() {
        logger.info("预热用户缓存...");
        // 模拟用户缓存预热
    }
    
    private void warmUpConfigCache() {
        logger.info("预热配置缓存...");
        // 模拟配置缓存预热
    }
    
    private void startServices() {
        logger.info("阶段4: 启动服务...");
        
        // 启动定时任务服务
        startScheduledTasks();
        
        // 启动消息监听服务
        startMessageListeners();
        
        logger.info("服务启动完成");
    }
    
    private void startScheduledTasks() {
        logger.info("启动定时任务...");
        // 模拟定时任务启动
    }
    
    private void startMessageListeners() {
        logger.info("启动消息监听器...");
        // 模拟消息监听器启动
    }
}