@FunctionalInterface
public interface CommandLineRunner {
    /**
     * 在SpringApplication啟動(dòng)后回調(diào)
     * @param args 來(lái)自應(yīng)用程序的命令行參數(shù)
     * @throws Exception 如果發(fā)生錯(cuò)誤
     */
    void run(String... args) throws Exception;
}

package com.example.demo.runner;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

/**
 * 簡(jiǎn)單的CommandLineRunner實(shí)現(xiàn)
 * 用于演示基本用法
 */
@Component
public class SimpleCommandLineRunner implements CommandLineRunner {

    private static final Logger logger = LoggerFactory.getLogger(SimpleCommandLineRunner.class);

    @Override
    public void run(String... args) throws Exception {
        logger.info("應(yīng)用啟動(dòng)完成，開(kāi)始執(zhí)行初始化操作...");
        
        // 執(zhí)行初始化邏輯
        logger.info("初始化操作完成");
        
        // 如果需要，可以訪問(wèn)命令行參數(shù)
        if (args.length > 0) {
            logger.info("接收到的命令行參數(shù)：");
            for (int i = 0; i < args.length; i++) {
                logger.info("參數(shù) {}: {}", i, args[i]);
            }
        }
    }
}

package com.example.demo.config;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 通過(guò)@Bean方法創(chuàng)建CommandLineRunner
 */
@Configuration
public class AppConfig {

    private static final Logger logger = LoggerFactory.getLogger(AppConfig.class);

    @Bean
    public CommandLineRunner initDatabase() {
        return args -> {
            logger.info("初始化數(shù)據(jù)庫(kù)連接池...");
            // 執(zhí)行數(shù)據(jù)庫(kù)初始化邏輯
        };
    }
    
    @Bean
    public CommandLineRunner loadCache() {
        return args -> {
            logger.info("預(yù)加載緩存數(shù)據(jù)...");
            // 執(zhí)行緩存預(yù)熱邏輯
        };
    }
}

package com.example.demo.runner;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

/**
 * 具有執(zhí)行順序的CommandLineRunner
 * Order值越小，優(yōu)先級(jí)越高，執(zhí)行越早
 */
@Component
@Order(1) // 優(yōu)先級(jí)高，最先執(zhí)行
public class DatabaseInitializer implements CommandLineRunner {

    private static final Logger logger = LoggerFactory.getLogger(DatabaseInitializer.class);

    @Override
    public void run(String... args) throws Exception {
        logger.info("第一步：初始化數(shù)據(jù)庫(kù)...");
        // 數(shù)據(jù)庫(kù)初始化邏輯
    }
}

@Component
@Order(2) // 次優(yōu)先級(jí)
public class CacheWarmer implements CommandLineRunner {

    private static final Logger logger = LoggerFactory.getLogger(CacheWarmer.class);

    @Override
    public void run(String... args) throws Exception {
        logger.info("第二步：預(yù)熱緩存...");
        // 緩存預(yù)熱邏輯
    }
}

@Component
@Order(3) // 最后執(zhí)行
public class NotificationInitializer implements CommandLineRunner {

    private static final Logger logger = LoggerFactory.getLogger(NotificationInitializer.class);

    @Override
    public void run(String... args) throws Exception {
        logger.info("第三步：初始化通知服務(wù)...");
        // 通知服務(wù)初始化邏輯
    }
}

package com.example.demo.runner;

import com.example.demo.service.UserService;
import com.example.demo.service.SystemConfigService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

/**
 * 演示在CommandLineRunner中使用依賴(lài)注入
 */
@Component
public class SystemInitializer implements CommandLineRunner {

    private static final Logger logger = LoggerFactory.getLogger(SystemInitializer.class);
    
    private final UserService userService;
    private final SystemConfigService configService;
    
    @Autowired
    public SystemInitializer(UserService userService, SystemConfigService configService) {
        this.userService = userService;
        this.configService = configService;
    }

    @Override
    public void run(String... args) throws Exception {
        logger.info("系統(tǒng)初始化開(kāi)始...");
        
        // 創(chuàng)建默認(rèn)管理員賬戶(hù)
        if (!userService.adminExists()) {
            logger.info("創(chuàng)建默認(rèn)管理員賬戶(hù)");
            userService.createDefaultAdmin();
        }
        
        // 加載系統(tǒng)配置
        logger.info("加載系統(tǒng)配置到內(nèi)存");
        configService.loadAllConfigurations();
        
        logger.info("系統(tǒng)初始化完成");
    }
}

package com.example.demo.runner;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

/**
 * 演示CommandLineRunner中的異常處理
 */
@Component
public class CriticalInitializer implements CommandLineRunner {

    private static final Logger logger = LoggerFactory.getLogger(CriticalInitializer.class);

    @Override
    public void run(String... args) throws Exception {
        logger.info("執(zhí)行關(guān)鍵初始化操作...");
        
        try {
            // 執(zhí)行可能失敗的操作
            boolean success = performCriticalOperation();
            
            if (!success) {
                // 如果操作未能成功完成，阻止應(yīng)用啟動(dòng)
                throw new RuntimeException("關(guān)鍵初始化操作失敗，應(yīng)用無(wú)法啟動(dòng)");
            }
            
            logger.info("關(guān)鍵初始化操作完成");
        } catch (Exception e) {
            logger.error("初始化過(guò)程中發(fā)生錯(cuò)誤: {}", e.getMessage());
            // 重新拋出異常，阻止應(yīng)用啟動(dòng)
            throw e;
        }
    }
    
    private boolean performCriticalOperation() {
        // 模擬關(guān)鍵操作的執(zhí)行
        return true; // 返回操作結(jié)果
    }
}

@Component
@Order(1)
public class DataMigrationRunner implements CommandLineRunner {

    private final DataMigrationService migrationService;
    private static final Logger logger = LoggerFactory.getLogger(DataMigrationRunner.class);
    
    @Autowired
    public DataMigrationRunner(DataMigrationService migrationService) {
        this.migrationService = migrationService;
    }

    @Override
    public void run(String... args) throws Exception {
        logger.info("檢查數(shù)據(jù)庫(kù)版本并執(zhí)行遷移...");
        
        // 獲取當(dāng)前數(shù)據(jù)庫(kù)版本
        String currentVersion = migrationService.getCurrentVersion();
        logger.info("當(dāng)前數(shù)據(jù)庫(kù)版本: {}", currentVersion);
        
        // 執(zhí)行遷移
        boolean migrationNeeded = migrationService.checkMigrationNeeded();
        if (migrationNeeded) {
            logger.info("需要執(zhí)行數(shù)據(jù)遷移");
            migrationService.performMigration();
            logger.info("數(shù)據(jù)遷移完成");
        } else {
            logger.info("無(wú)需數(shù)據(jù)遷移");
        }
    }
}

@Component
public class SchedulerInitializer implements CommandLineRunner {

    private final TaskSchedulerService schedulerService;
    private final TaskDefinitionRepository taskRepository;
    private static final Logger logger = LoggerFactory.getLogger(SchedulerInitializer.class);
    
    @Autowired
    public SchedulerInitializer(TaskSchedulerService schedulerService, 
                               TaskDefinitionRepository taskRepository) {
        this.schedulerService = schedulerService;
        this.taskRepository = taskRepository;
    }

    @Override
    public void run(String... args) throws Exception {
        logger.info("初始化任務(wù)調(diào)度器...");
        
        // 從數(shù)據(jù)庫(kù)加載任務(wù)定義
        List<TaskDefinition> tasks = taskRepository.findAllActiveTasks();
        logger.info("加載了{(lán)}個(gè)調(diào)度任務(wù)", tasks.size());
        
        // 注冊(cè)任務(wù)到調(diào)度器
        for (TaskDefinition task : tasks) {
            schedulerService.scheduleTask(task);
            logger.info("注冊(cè)任務(wù): {}, cron: {}", task.getName(), task.getCronExpression());
        }
        
        logger.info("任務(wù)調(diào)度器初始化完成");
    }
}

@Component
public class ExternalSystemConnectionTester implements CommandLineRunner {

    private final List<ExternalSystemConnector> connectors;
    private static final Logger logger = LoggerFactory.getLogger(ExternalSystemConnectionTester.class);
    
    @Autowired
    public ExternalSystemConnectionTester(List<ExternalSystemConnector> connectors) {
        this.connectors = connectors;
    }

    @Override
    public void run(String... args) throws Exception {
        logger.info("測(cè)試外部系統(tǒng)連接...");
        
        for (ExternalSystemConnector connector : connectors) {
            String systemName = connector.getSystemName();
            logger.info("測(cè)試連接到: {}", systemName);
            
            try {
                boolean connected = connector.testConnection();
                if (connected) {
                    logger.info("{} 連接成功", systemName);
                } else {
                    logger.warn("{} 連接失敗，但不阻止應(yīng)用啟動(dòng)", systemName);
                }
            } catch (Exception e) {
                logger.error("{} 連接異常: {}", systemName, e.getMessage());
                // 根據(jù)系統(tǒng)重要性決定是否拋出異常阻止應(yīng)用啟動(dòng)
            }
        }
        
        logger.info("外部系統(tǒng)連接測(cè)試完成");
    }
}

@Component
public class AsyncInitializer implements CommandLineRunner {

    private final TaskExecutor taskExecutor;
    private static final Logger logger = LoggerFactory.getLogger(AsyncInitializer.class);
    
    @Autowired
    public AsyncInitializer(TaskExecutor taskExecutor) {
        this.taskExecutor = taskExecutor;
    }

    @Override
    public void run(String... args) throws Exception {
        logger.info("啟動(dòng)異步初始化任務(wù)...");
        
        taskExecutor.execute(() -> {
            try {
                logger.info("異步任務(wù)開(kāi)始執(zhí)行");
                Thread.sleep(5000); // 模擬耗時(shí)操作
                logger.info("異步任務(wù)執(zhí)行完成");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                logger.error("異步任務(wù)被中斷", e);
            } catch (Exception e) {
                logger.error("異步任務(wù)執(zhí)行失敗", e);
            }
        });
        
        logger.info("異步初始化任務(wù)已提交，應(yīng)用繼續(xù)啟動(dòng)");
    }
}

@Component
@ConditionalOnProperty(name = "app.cache.preload", havingValue = "true")
public class ConditionalInitializer implements CommandLineRunner {

    private static final Logger logger = LoggerFactory.getLogger(ConditionalInitializer.class);

    @Override
    public void run(String... args) throws Exception {
        logger.info("執(zhí)行條件初始化任務(wù)，僅在配置啟用時(shí)執(zhí)行");
        // 僅在特定條件下執(zhí)行的初始化邏輯
    }
}