@Service
public class ProductService {
    @Autowired
    private RedisTemplate<String, Product> redisTemplate;
    
    // 配置本地緩存
    private Cache<String, Product> localCache = Caffeine.newBuilder()
            .expireAfterWrite(5, TimeUnit.MINUTES)
            .maximumSize(1000)
            .build();
    
    @Autowired
    private ProductRepository productRepository;
    
    private final AtomicBoolean redisAvailable = new AtomicBoolean(true);
    
    public Product getProductById(String productId) {
        Product product = null;
        
        // 嘗試從Redis獲取
        if (redisAvailable.get()) {
            try {
                product = redisTemplate.opsForValue().get("product:" + productId);
            } catch (Exception e) {
                // Redis異常，標(biāo)記為不可用，記錄日志
                redisAvailable.set(false);
                log.warn("Redis unavailable, switching to local cache", e);
                // 啟動后臺定時任務(wù)檢測Redis恢復(fù)
                scheduleRedisRecoveryCheck();
            }
        }
        
        // 如果Redis不可用或未命中，嘗試本地緩存
        if (product == null) {
            product = localCache.getIfPresent(productId);
        }
        
        // 如果本地緩存也未命中，從數(shù)據(jù)庫加載
        if (product == null) {
            product = productRepository.findById(productId).orElse(null);
            
            // 如果找到產(chǎn)品，更新本地緩存
            if (product != null) {
                localCache.put(productId, product);
                
                // 如果Redis可用，也更新Redis緩存
                if (redisAvailable.get()) {
                    try {
                        redisTemplate.opsForValue().set("product:" + productId, product, 30, TimeUnit.MINUTES);
                    } catch (Exception e) {
                        // 更新失敗僅記錄日志，不影響返回結(jié)果
                        log.error("Failed to update Redis cache", e);
                    }
                }
            }
        }
        
        return product;
    }
    
    // 定時檢查Redis是否恢復(fù)
    private void scheduleRedisRecoveryCheck() {
        ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
        scheduler.scheduleAtFixedRate(() -> {
            try {
                redisTemplate.getConnectionFactory().getConnection().ping();
                redisAvailable.set(true);
                log.info("Redis service recovered");
                scheduler.shutdown();
            } catch (Exception e) {
                log.debug("Redis still unavailable");
            }
        }, 30, 30, TimeUnit.SECONDS);
    }
}

@Service
public class RecommendationService {
    @Autowired
    private RedisTemplate<String, List<ProductRecommendation>> redisTemplate;
    
    @Autowired
    private RecommendationEngine recommendationEngine;
    
    // 預(yù)加載的靜態(tài)推薦數(shù)據(jù)，可以在應(yīng)用啟動時初始化
    private static final List<ProductRecommendation> DEFAULT_RECOMMENDATIONS = new ArrayList<>();
    
    static {
        // 初始化一些通用熱門商品作為默認推薦
        DEFAULT_RECOMMENDATIONS.add(new ProductRecommendation("1001", "熱門商品1", 4.8));
        DEFAULT_RECOMMENDATIONS.add(new ProductRecommendation("1002", "熱門商品2", 4.7));
        DEFAULT_RECOMMENDATIONS.add(new ProductRecommendation("1003", "熱門商品3", 4.9));
        // 更多默認推薦...
    }
    
    public List<ProductRecommendation> getRecommendationsForUser(String userId) {
        String cacheKey = "recommendations:" + userId;
        
        try {
            // 嘗試從Redis獲取個性化推薦
            List<ProductRecommendation> cachedRecommendations = redisTemplate.opsForValue().get(cacheKey);
            
            if (cachedRecommendations != null) {
                return cachedRecommendations;
            }
            
            // 緩存未命中，生成新的推薦
            List<ProductRecommendation> freshRecommendations = recommendationEngine.generateForUser(userId);
            
            // 緩存推薦結(jié)果
            if (freshRecommendations != null && !freshRecommendations.isEmpty()) {
                redisTemplate.opsForValue().set(cacheKey, freshRecommendations, 1, TimeUnit.HOURS);
                return freshRecommendations;
            } else {
                // 推薦引擎返回空結(jié)果，使用默認推薦
                return DEFAULT_RECOMMENDATIONS;
            }
        } catch (Exception e) {
            // Redis或推薦引擎異常，返回默認推薦
            log.warn("Failed to get recommendations, using defaults", e);
            return DEFAULT_RECOMMENDATIONS;
        }
    }
}

@Service
public class UserProfileService {
    @Autowired
    private RedisTemplate<String, UserProfile> redisTemplate;
    
    @Autowired
    private UserRepository userRepository;
    
    @Value("${feature.profile.full-mode:true}")
    private boolean fullProfileMode;
    
    @Value("${feature.profile.use-cache:true}")
    private boolean useCache;
    
    // Apollo配置中心監(jiān)聽器自動刷新配置
    @ApolloConfigChangeListener
    private void onChange(ConfigChangeEvent changeEvent) {
        if (changeEvent.isChanged("feature.profile.full-mode")) {
            fullProfileMode = Boolean.parseBoolean(changeEvent.getChange("feature.profile.full-mode").getNewValue());
        }
        if (changeEvent.isChanged("feature.profile.use-cache")) {
            useCache = Boolean.parseBoolean(changeEvent.getChange("feature.profile.use-cache").getNewValue());
        }
    }
    
    public UserProfile getUserProfile(String userId) {
        if (!useCache) {
            // 緩存降級開關(guān)已啟用，直接查詢數(shù)據(jù)庫
            return getUserProfileFromDb(userId, fullProfileMode);
        }
        
        // 嘗試從緩存獲取
        try {
            UserProfile profile = redisTemplate.opsForValue().get("user:profile:" + userId);
            if (profile != null) {
                return profile;
            }
        } catch (Exception e) {
            // 緩存異常時記錄日志，并繼續(xù)從數(shù)據(jù)庫獲取
            log.warn("Redis cache failure when getting user profile", e);
            // 可以在這里觸發(fā)自動降級開關(guān)
            triggerAutoDegradation("profile.cache");
        }
        
        // 緩存未命中或異常，從數(shù)據(jù)庫獲取
        return getUserProfileFromDb(userId, fullProfileMode);
    }
    
    // 根據(jù)fullProfileMode決定是否加載完整或簡化的用戶資料
    private UserProfile getUserProfileFromDb(String userId, boolean fullMode) {
        if (fullMode) {
            // 獲取完整用戶資料，包括詳細信息、偏好設(shè)置等
            UserProfile fullProfile = userRepository.findFullProfileById(userId);
            try {
                // 嘗試更新緩存，但不影響主流程
                if (useCache) {
                    redisTemplate.opsForValue().set("user:profile:" + userId, fullProfile, 30, TimeUnit.MINUTES);
                }
            } catch (Exception e) {
                log.error("Failed to update user profile cache", e);
            }
            return fullProfile;
        } else {
            // 降級模式：只獲取基本用戶信息
            return userRepository.findBasicProfileById(userId);
        }
    }
    
    // 觸發(fā)自動降級
    private void triggerAutoDegradation(String feature) {
        // 實現(xiàn)自動降級邏輯，如通過配置中心API修改配置
        // 或更新本地降級狀態(tài)，在達到閾值后自動降級
    }
}

@Service
public class ProductCatalogService {
    @Autowired
    private RedisTemplate<String, List<Product>> redisTemplate;
    
    @Autowired
    private ProductCatalogRepository repository;
    
    // 創(chuàng)建熔斷器
    private final CircuitBreaker circuitBreaker = CircuitBreaker.ofDefaults("redisCatalogCache");
    
    // 創(chuàng)建限流器
    private final RateLimiter rateLimiter = RateLimiter.of("catalogService", RateLimiterConfig.custom()
            .limitRefreshPeriod(Duration.ofSeconds(1))
            .limitForPeriod(1000) // 每秒允許1000次請求
            .timeoutDuration(Duration.ofMillis(25))
            .build());
    
    public List<Product> getProductsByCategory(String category, int page, int size) {
        // 應(yīng)用限流
        rateLimiter.acquirePermission();
        
        String cacheKey = "products:category:" + category + ":" + page + ":" + size;
        
        // 使用熔斷器包裝Redis調(diào)用
        Supplier<List<Product>> redisCall = CircuitBreaker.decorateSupplier(
                circuitBreaker, 
                () -> redisTemplate.opsForValue().get(cacheKey)
        );
        
        try {
            // 嘗試從Redis獲取數(shù)據(jù)
            List<Product> products = redisCall.get();
            if (products != null) {
                return products;
            }
        } catch (Exception e) {
            // 熔斷器會處理異常，這里只需記錄日志
            log.warn("Failed to get products from cache, fallback to database", e);
        }
        
        // 熔斷或緩存未命中，從數(shù)據(jù)庫加載
        List<Product> products = repository.findByCategory(category, PageRequest.of(page, size));
        
        // 只在熔斷器閉合狀態(tài)下更新緩存
        if (circuitBreaker.getState() == CircuitBreaker.State.CLOSED) {
            try {
                redisTemplate.opsForValue().set(cacheKey, products, 1, TimeUnit.HOURS);
            } catch (Exception e) {
                log.error("Failed to update product cache", e);
            }
        }
        
        return products;
    }
    
    // 提供熔斷器狀態(tài)監(jiān)控端點
    public CircuitBreakerStatus getCircuitBreakerStatus() {
        return new CircuitBreakerStatus(
                circuitBreaker.getState().toString(),
                circuitBreaker.getMetrics().getFailureRate(),
                circuitBreaker.getMetrics().getNumberOfBufferedCalls(),
                circuitBreaker.getMetrics().getNumberOfFailedCalls()
        );
    }
    
    // 值對象：熔斷器狀態(tài)
    @Data
    @AllArgsConstructor
    public static class CircuitBreakerStatus {
        private String state;
        private float failureRate;
        private int totalCalls;
        private int failedCalls;
    }
}