public class RandomExpiryTimeCache {
    private RedisTemplate<String, Object> redisTemplate;
    private Random random = new Random();
    
    public RandomExpiryTimeCache(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }
    
    /**
     * 設置緩存值與隨機過期時間
     * @param key 緩存鍵
     * @param value 緩存值
     * @param baseTimeSeconds 基礎過期時間(秒)
     * @param randomRangeSeconds 隨機時間范圍(秒)
     */
    public void setWithRandomExpiry(String key, Object value, long baseTimeSeconds, long randomRangeSeconds) {
        // 生成隨機增量時間
        long randomSeconds = random.nextInt((int) randomRangeSeconds);
        // 計算最終過期時間
        long finalExpiry = baseTimeSeconds + randomSeconds;
        
        redisTemplate.opsForValue().set(key, value, finalExpiry, TimeUnit.SECONDS);
        
        log.debug("Set cache key: {} with expiry time: {}", key, finalExpiry);
    }
    
    /**
     * 批量設置帶隨機過期時間的緩存
     */
    public void setBatchWithRandomExpiry(Map<String, Object> keyValueMap, long baseTimeSeconds, long randomRangeSeconds) {
        keyValueMap.forEach((key, value) -> setWithRandomExpiry(key, value, baseTimeSeconds, randomRangeSeconds));
    }
}

@Service
public class ProductCacheService {
    @Autowired
    private RandomExpiryTimeCache randomCache;
    
    @Autowired
    private ProductRepository productRepository;
    
    /**
     * 獲取商品詳情，使用隨機過期時間緩存
     */
    public Product getProductDetail(String productId) {
        String cacheKey = "product:detail:" + productId;
        Product product = (Product) redisTemplate.opsForValue().get(cacheKey);
        
        if (product == null) {
            // 緩存未命中，從數(shù)據(jù)庫加載
            product = productRepository.findById(productId).orElse(null);
            
            if (product != null) {
                // 設置緩存，基礎過期時間30分鐘，隨機范圍10分鐘
                randomCache.setWithRandomExpiry(cacheKey, product, 30 * 60, 10 * 60);
            }
        }
        
        return product;
    }
    
    /**
     * 緩存首頁商品列表，使用隨機過期時間
     */
    public void cacheHomePageProducts(List<Product> products) {
        String cacheKey = "products:homepage";
        // 基礎過期時間1小時，隨機范圍20分鐘
        randomCache.setWithRandomExpiry(cacheKey, products, 60 * 60, 20 * 60);
    }
}

@Component
public class CacheWarmUpService {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Autowired
    private ProductRepository productRepository;
    
    @Autowired
    private CategoryRepository categoryRepository;
    
    private ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(5);
    
    /**
     * 系統(tǒng)啟動時執(zhí)行緩存預熱
     */
    @PostConstruct
    public void warmUpCacheOnStartup() {
        log.info("Starting cache warm-up process...");
        
        CompletableFuture.runAsync(this::warmUpHotProducts);
        CompletableFuture.runAsync(this::warmUpCategories);
        CompletableFuture.runAsync(this::warmUpHomePageData);
        
        log.info("Cache warm-up tasks submitted");
    }
    
    /**
     * 預熱熱門商品數(shù)據(jù)
     */
    private void warmUpHotProducts() {
        try {
            log.info("Warming up hot products cache");
            List<Product> hotProducts = productRepository.findTop100ByOrderByViewCountDesc();
            
            // 批量設置緩存，基礎TTL 2小時，隨機范圍30分鐘
            Map<String, Object> productCacheMap = new HashMap<>();
            hotProducts.forEach(product -> {
                String key = "product:detail:" + product.getId();
                productCacheMap.put(key, product);
            });
            
            redisTemplate.opsForValue().multiSet(productCacheMap);
            
            // 設置過期時間
            productCacheMap.keySet().forEach(key -> {
                int randomSeconds = 7200 + new Random().nextInt(1800);
                redisTemplate.expire(key, randomSeconds, TimeUnit.SECONDS);
            });
            
            // 安排定時刷新，在過期前30分鐘刷新
            scheduleRefresh("hotProducts", this::warmUpHotProducts, 90, TimeUnit.MINUTES);
            
            log.info("Successfully warmed up {} hot products", hotProducts.size());
        } catch (Exception e) {
            log.error("Failed to warm up hot products cache", e);
        }
    }
    
    /**
     * 預熱分類數(shù)據(jù)
     */
    private void warmUpCategories() {
        // 類似實現(xiàn)...
    }
    
    /**
     * 預熱首頁數(shù)據(jù)
     */
    private void warmUpHomePageData() {
        // 類似實現(xiàn)...
    }
    
    /**
     * 安排定時刷新任務
     */
    private void scheduleRefresh(String taskName, Runnable task, long delay, TimeUnit timeUnit) {
        scheduler.schedule(() -> {
            log.info("Executing scheduled refresh for: {}", taskName);
            try {
                task.run();
            } catch (Exception e) {
                log.error("Error during scheduled refresh of {}", taskName, e);
                // 發(fā)生錯誤時，安排短期重試
                scheduler.schedule(task, 5, TimeUnit.MINUTES);
            }
        }, delay, timeUnit);
    }
    
    /**
     * 應用關閉時清理資源
     */
    @PreDestroy
    public void shutdown() {
        scheduler.shutdown();
    }
}

@Service
public class MutexCacheService {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Autowired
    private ProductRepository productRepository;
    
    // 鎖的默認過期時間
    private static final long LOCK_EXPIRY_MS = 3000;
    
    /**
     * 使用互斥鎖方式獲取商品數(shù)據(jù)
     */
    public Product getProductWithMutex(String productId) {
        String cacheKey = "product:detail:" + productId;
        String lockKey = "lock:product:detail:" + productId;
        
        // 嘗試從緩存獲取
        Product product = (Product) redisTemplate.opsForValue().get(cacheKey);
        
        // 緩存命中，直接返回
        if (product != null) {
            return product;
        }
        
        // 定義最大重試次數(shù)和等待時間
        int maxRetries = 3;
        long retryIntervalMs = 50;
        
        // 重試獲取鎖
        for (int i = 0; i <= maxRetries; i++) {
            boolean locked = false;
            try {
                // 嘗試獲取鎖
                locked = tryLock(lockKey, LOCK_EXPIRY_MS);
                
                if (locked) {
                    // 雙重檢查
                    product = (Product) redisTemplate.opsForValue().get(cacheKey);
                    if (product != null) {
                        return product;
                    }
                    
                    // 從數(shù)據(jù)庫加載
                    product = productRepository.findById(productId).orElse(null);
                    
                    if (product != null) {
                        // 設置緩存
                        int expiry = 3600 + new Random().nextInt(300);
                        redisTemplate.opsForValue().set(cacheKey, product, expiry, TimeUnit.SECONDS);
                    } else {
                        // 設置空值緩存
                        redisTemplate.opsForValue().set(cacheKey, new EmptyProduct(), 60, TimeUnit.SECONDS);
                    }
                    
                    return product;
                } else if (i < maxRetries) {
                    // 使用隨機退避策略，避免所有線程同時重試
                    long backoffTime = retryIntervalMs * (1L << i) + new Random().nextInt(50);
                    Thread.sleep(Math.min(backoffTime, 1000)); // 最大等待1秒
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                log.error("Interrupted while waiting for mutex lock", e);
                break; // 中斷時退出循環(huán)
            } catch (Exception e) {
                log.error("Error getting product with mutex", e);
                break; // 發(fā)生異常時退出循環(huán)
            } finally {
                if (locked) {
                    unlock(lockKey);
                }
            }
        }
        
        // 達到最大重試次數(shù)仍未獲取到鎖，返回可能舊的緩存值或默認值
        product = (Product) redisTemplate.opsForValue().get(cacheKey);
        return product != null ? product : getDefaultProduct(productId);
    }

    // 提供默認值或降級策略
    private Product getDefaultProduct(String productId) {
        log.warn("Failed to get product after max retries: {}", productId);
        // 返回基礎信息或空對象
        return new BasicProduct(productId);
    }
    
    /**
     * 嘗試獲取分布式鎖
     */
    private boolean tryLock(String key, long expiryTimeMs) {
        Boolean result = stringRedisTemplate.opsForValue().setIfAbsent(key, "locked", expiryTimeMs, TimeUnit.MILLISECONDS);
        return Boolean.TRUE.equals(result);
    }
    
    /**
     * 釋放分布式鎖
     */
    private void unlock(String key) {
        stringRedisTemplate.delete(key);
    }
}

@RestController
@RequestMapping("/api/products")
public class ProductController {
    @Autowired
    private MutexCacheService mutexCacheService;
    
    @GetMapping("/{id}")
    public ResponseEntity<Product> getProduct(@PathVariable("id") String id) {
        // 使用互斥鎖方式獲取商品
        Product product = mutexCacheService.getProductWithMutex(id);
        
        if (product instanceof EmptyProduct) {
            return ResponseEntity.notFound().build();
        }
        
        return ResponseEntity.ok(product);
    }
}

@Service
public class MultiLevelCacheService {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Autowired
    private ProductRepository productRepository;
    
    // 本地緩存配置
    private LoadingCache<String, Optional<Product>> localCache = CacheBuilder.newBuilder()
            .maximumSize(10000)  // 最多緩存10000個商品
            .expireAfterWrite(5, TimeUnit.MINUTES)  // 本地緩存5分鐘后過期
            .recordStats()  // 記錄緩存統(tǒng)計信息
            .build(new CacheLoader<String, Optional<Product>>() {
                @Override
                public Optional<Product> load(String productId) throws Exception {
                    // 本地緩存未命中時，嘗試從Redis加載
                    return loadFromRedis(productId);
                }
            });
    
    /**
     * 多級緩存查詢商品
     */
    public Product getProduct(String productId) {
        String cacheKey = "product:detail:" + productId;
        
        try {
            // 首先查詢本地緩存
            Optional<Product> productOptional = localCache.get(productId);
            
            if (productOptional.isPresent()) {
                log.debug("Product {} found in local cache", productId);
                return productOptional.get();
            } else {
                log.debug("Product {} not found in any cache level", productId);
                return null;
            }
        } catch (ExecutionException e) {
            log.error("Error loading product from cache", e);
            
            // 所有緩存層都失敗，直接查詢數(shù)據(jù)庫作為最后手段
            try {
                Product product = productRepository.findById(productId).orElse(null);
                
                if (product != null) {
                    // 嘗試更新緩存，但不阻塞當前請求
                    CompletableFuture.runAsync(() -> {
                        try {
                            updateCache(cacheKey, product);
                        } catch (Exception ex) {
                            log.error("Failed to update cache asynchronously", ex);
                        }
                    });
                }
                
                return product;
            } catch (Exception dbEx) {
                log.error("Database query failed as last resort", dbEx);
                throw new ServiceException("Failed to fetch product data", dbEx);
            }
        }
    }
    
    /**
     * 從Redis加載數(shù)據(jù)
     */
    private Optional<Product> loadFromRedis(String productId) {
        String cacheKey = "product:detail:" + productId;
        
        try {
            Product product = (Product) redisTemplate.opsForValue().get(cacheKey);
            
            if (product != null) {
                log.debug("Product {} found in Redis cache", productId);
                return Optional.of(product);
            }
            
            // Redis緩存未命中，查詢數(shù)據(jù)庫
            product = productRepository.findById(productId).orElse(null);
            
            if (product != null) {
                // 更新Redis緩存
                updateCache(cacheKey, product);
                return Optional.of(product);
            } else {
                // 設置空值緩存
                redisTemplate.opsForValue().set(cacheKey, new EmptyProduct(), 60, TimeUnit.SECONDS);
                return Optional.empty();
            }
        } catch (Exception e) {
            log.warn("Failed to access Redis cache, falling back to database", e);
            
            // Redis訪問失敗，直接查詢數(shù)據(jù)庫
            Product product = productRepository.findById(productId).orElse(null);
            return Optional.ofNullable(product);
        }
    }
    
    /**
     * 更新緩存
     */
    private void updateCache(String key, Product product) {
        // 更新Redis，設置隨機過期時間
        int expiry = 3600 + new Random().nextInt(300);
        redisTemplate.opsForValue().set(key, product, expiry, TimeUnit.SECONDS);
    }
    
    /**
     * 主動刷新所有級別的緩存
     */
    public void refreshCache(String productId) {
        String cacheKey = "product:detail:" + productId;
        
        // 從數(shù)據(jù)庫加載最新數(shù)據(jù)
        Product product = productRepository.findById(productId).orElse(null);
        
        if (product != null) {
            // 更新Redis緩存
            updateCache(cacheKey, product);
            
            // 更新本地緩存
            localCache.put(productId, Optional.of(product));
            
            log.info("Refreshed all cache levels for product {}", productId);
        } else {
            // 刪除各級緩存
            redisTemplate.delete(cacheKey);
            localCache.invalidate(productId);
            
            log.info("Product {} not found, invalidated all cache levels", productId);
        }
    }
    
    /**
     * 獲取緩存統(tǒng)計信息
     */
    public Map<String, Object> getCacheStats() {
        CacheStats stats = localCache.stats();
        
        Map<String, Object> result = new HashMap<>();
        result.put("localCacheSize", localCache.size());
        result.put("hitRate", stats.hitRate());
        result.put("missRate", stats.missRate());
        result.put("loadSuccessCount", stats.loadSuccessCount());
        result.put("loadExceptionCount", stats.loadExceptionCount());
        
        return result;
    }
}

@Service
public class ResilientCacheService {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Autowired
    private ProductRepository productRepository;
    
    // 注入熔斷器工廠
    @Autowired
    private CircuitBreakerFactory circuitBreakerFactory;
    
    // 注入限流器
    @Autowired
    private RateLimiter productRateLimiter;
    
    /**
     * 帶熔斷和限流的商品查詢
     */
    public Product getProductWithResilience(String productId) {
        // 應用限流
        if (!productRateLimiter.tryAcquire()) {
            log.warn("Rate limit exceeded for product query: {}", productId);
            return getFallbackProduct(productId);
        }
        
        // 創(chuàng)建熔斷器
        CircuitBreaker circuitBreaker = circuitBreakerFactory.create("redisProductQuery");
        
        // 包裝Redis緩存查詢
        Function<String, Product> redisQueryWithFallback = id -> {
            try {
                String cacheKey = "product:detail:" + id;
                Product product = (Product) redisTemplate.opsForValue().get(cacheKey);
                
                if (product != null) {
                    return product;
                }
                
                // 緩存未命中時，從數(shù)據(jù)庫加載
                product = loadFromDatabase(id);
                
                if (product != null) {
                    // 異步更新緩存，不阻塞主請求
                    CompletableFuture.runAsync(() -> {
                        int expiry = 3600 + new Random().nextInt(300);
                        redisTemplate.opsForValue().set(cacheKey, product, expiry, TimeUnit.SECONDS);
                    });
                }
                
                return product;
            } catch (Exception e) {
                log.error("Redis query failed", e);
                throw e; // 重新拋出異常以觸發(fā)熔斷器
            }
        };
        
        // 執(zhí)行帶熔斷保護的查詢
        try {
            return circuitBreaker.run(() -> redisQueryWithFallback.apply(productId), 
                                    throwable -> getFallbackProduct(productId));
        } catch (Exception e) {
            log.error("Circuit breaker execution failed", e);
            return getFallbackProduct(productId);
        }
    }
    
    /**
     * 從數(shù)據(jù)庫加載商品數(shù)據(jù)
     */
    private Product loadFromDatabase(String productId) {
        try {
            return productRepository.findById(productId).orElse(null);
        } catch (Exception e) {
            log.error("Database query failed", e);
            return null;
        }
    }
    
    /**
     * 降級后的兜底策略 - 返回基礎商品信息或緩存的舊數(shù)據(jù)
     */
    private Product getFallbackProduct(String productId) {
        log.info("Using fallback for product: {}", productId);
        
        // 優(yōu)先嘗試從本地緩存獲取舊數(shù)據(jù)
        Product cachedProduct = getFromLocalCache(productId);
        if (cachedProduct != null) {
            return cachedProduct;
        }
        
        // 如果是重要商品，嘗試從數(shù)據(jù)庫獲取基本信息
        if (isHighPriorityProduct(productId)) {
            try {
                return productRepository.findBasicInfoById(productId);
            } catch (Exception e) {
                log.error("Even basic info query failed for high priority product", e);
            }
        }
        
        // 最終兜底：構(gòu)建一個臨時對象，包含最少的必要信息
        return buildTemporaryProduct(productId);
    }
    
    // 輔助方法實現(xiàn)...
    
    /**
     * 熔斷器狀態(tài)監(jiān)控API
     */
    public Map<String, Object> getCircuitBreakerStatus() {
        CircuitBreaker circuitBreaker = circuitBreakerFactory.create("redisProductQuery");
        
        Map<String, Object> status = new HashMap<>();
        status.put("state", circuitBreaker.getState().name());
        status.put("failureRate", circuitBreaker.getMetrics().getFailureRate());
        status.put("failureCount", circuitBreaker.getMetrics().getNumberOfFailedCalls());
        status.put("successCount", circuitBreaker.getMetrics().getNumberOfSuccessfulCalls());
        
        return status;
    }
}

@Configuration
public class ResilienceConfig {
    
    @Bean
    public CircuitBreakerFactory circuitBreakerFactory() {
        // 使用Resilience4j實現(xiàn)
        Resilience4JCircuitBreakerFactory factory = new Resilience4JCircuitBreakerFactory();
        
        // 自定義熔斷器配置
        factory.configureDefault(id -> new Resilience4JConfigBuilder(id)
                .circuitBreakerConfig(CircuitBreakerConfig.custom()
                        .slidingWindowSize(10)  // 滑動窗口大小
                        .failureRateThreshold(50)  // 失敗率閾值
                        .waitDurationInOpenState(Duration.ofSeconds(10))  // 熔斷器打開持續(xù)時間
                        .permittedNumberOfCallsInHalfOpenState(5)  // 半開狀態(tài)允許的調(diào)用次數(shù)
                        .build())
                .build());
        
        return factory;
    }
    
    @Bean
    public RateLimiter productRateLimiter() {
        // 使用Guava實現(xiàn)基本的限流器
        return RateLimiter.create(1000);  // 每秒允許1000個請求
    }
}