@Service
public class CacheInitializer {
    
    @PostConstruct
    public void init() {
        // 在 Bean 初始化完成后執(zhí)行
        loadAllConfigToCache();
        System.out.println("字典數(shù)據(jù)加載完成");
    }
}

java
@Component
@Order(1) // 控制執(zhí)行順序
public class StartupRunner implements ApplicationRunner {

    @Override
    public void run(ApplicationArguments args) {
        // 解析命令行參數(shù)
        boolean force = args.containsOption("force");
        String configFile = args.getOptionValues("config").get(0);
        
        // 執(zhí)行初始化邏輯
        System.out.println("使用參數(shù)啟動：force="+force+", configFile="+configFile);
    }
}

@Component
public class ApplicationReadyListener {
    
    @EventListener(ApplicationReadyEvent.class)
    public void onApplicationReady() {
        // 確保所有 Bean 初始化完成
        System.out.println("所有組件就緒，執(zhí)行最終初始化");
    }
}

@Component
public class ConfigLoader implements CommandLineRunner {
    
    @Override
    public void run(String... args) {
        // 處理原始命令行參數(shù)
        System.out.println("原始參數(shù)："+Arrays.toString(args));
    }
}

@Component
public class StartupListener implements ApplicationListener<ContextRefreshedEvent> {
    
    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        if (event.getApplicationContext().getParent() == null) {
            // 只在根上下文初始化時執(zhí)行
            System.out.println("根上下文初始化完成");
        }
    }
}

@Component
@EnableScheduling
public class DelayedInitializer {
    
    @Scheduled(fixedDelay = 5000) // 首次延遲5秒后執(zhí)行
    public void delayedInit() {
        System.out.println("延遲初始化任務(wù)執(zhí)行");
    }
}

@Service
public class StartupService {
    
    public void initConfig() {
        // 加載配置邏輯
    }
    
    public void warmUpCache() {
        // 緩存預熱邏輯
    }
}

@Component
@Order(1)
public class StartupRunner implements ApplicationRunner {
    
    private final StartupService startupService;
    
    public StartupRunner(StartupService startupService) {
        this.startupService = startupService;
    }

    @Override
    public void run(ApplicationArguments args) {
        startupService.initConfig();
        startupService.warmUpCache();
    }
}

@Component
@Order(2)
public class SecondaryInitializer implements CommandLineRunner {
    // 次級初始化任務(wù)
}

// 錯誤示例：A 依賴 B，B 依賴 A
@Service
public class AService {
    private final BService bService;
    
    public AService(BService bService) {
        this.bService = bService;
    }
    
    @PostConstruct
    public void init() {
        bService.doSomething(); // 觸發(fā)循環(huán)依賴
    }
}

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

???????// 在方法上添加異步執(zhí)行
@Async
public void asyncInit() {
    // 異步初始化邏輯
}

@Component
@Order(1) // 數(shù)字越小優(yōu)先級越高
public class FirstInitializer implements ApplicationRunner {}

@Component
@Order(2)
public class SecondInitializer implements ApplicationRunner {}

@SpringBootTest
class StartupTest {
    
    @Autowired
    private StartupService startupService;
    
    @Test
    void testInitSequence() {
        // 驗證初始化順序
        verifyOrder(startupService::initConfig, startupService::warmUpCache);
    }
}

@PostConstruct
public void distributedInit() {
    RLock lock = redissonClient.getLock("startup:init");
    if (lock.tryLock(0, 60, TimeUnit.SECONDS)) {
        try {
            // 執(zhí)行初始化
        } finally {
            lock.unlock();
        }
    }
}

@EventListener(ApplicationReadyEvent.class)
public void healthCheck() {
    HealthIndicator indicator = context.getBean(HealthIndicator.class);
    if (!indicator.health().getStatus().equals(Status.UP)) {
        throw new RuntimeException("依賴服務(wù)未就緒");
    }
}