@Service
public class UserServiceImpl implements UserService {
    
    @Autowired
    private StringRedisTemplate redisTemplate;
    
    @Autowired
    private UserMapper userMapper;
    
    private static final String KEY_PREFIX = "user:";
    private static final String EMPTY_VALUE = "{}";  // 空值標(biāo)記
    private static final long EMPTY_VALUE_EXPIRE_SECONDS = 300;  // 空值過(guò)期時(shí)間
    private static final long NORMAL_EXPIRE_SECONDS = 3600;  // 正常值過(guò)期時(shí)間
    
    @Override
    public User getUserById(Long userId) {
        String redisKey = KEY_PREFIX + userId;
        
        // 1. 查詢(xún)緩存
        String userJson = redisTemplate.opsForValue().get(redisKey);
        
        // 2. 緩存命中
        if (userJson != null) {
            // 判斷是否為空值
            if (EMPTY_VALUE.equals(userJson)) {
                return null;  // 返回空結(jié)果
            }
            // 正常緩存，反序列化并返回
            return JSON.parseObject(userJson, User.class);
        }
        
        // 3. 緩存未命中，查詢(xún)數(shù)據(jù)庫(kù)
        User user = userMapper.selectById(userId);
        
        // 4. 寫(xiě)入緩存
        if (user != null) {
            // 數(shù)據(jù)庫(kù)查到數(shù)據(jù)，寫(xiě)入正常緩存
            redisTemplate.opsForValue().set(redisKey, 
                                           JSON.toJSONString(user), 
                                           NORMAL_EXPIRE_SECONDS, 
                                           TimeUnit.SECONDS);
        } else {
            // 數(shù)據(jù)庫(kù)未查到數(shù)據(jù)，寫(xiě)入空值緩存
            redisTemplate.opsForValue().set(redisKey, 
                                           EMPTY_VALUE, 
                                           EMPTY_VALUE_EXPIRE_SECONDS, 
                                           TimeUnit.SECONDS);
        }
        
        return user;
    }
}

@Service
public class ProductServiceWithBloomFilter implements ProductService {
    
    @Autowired
    private StringRedisTemplate redisTemplate;
    
    @Autowired
    private ProductMapper productMapper;
    
    private static final String BLOOM_FILTER_NAME = "product_filter";
    private static final String CACHE_KEY_PREFIX = "product:";
    private static final long CACHE_EXPIRE_SECONDS = 3600;
    
    // 初始化布隆過(guò)濾器，可在應(yīng)用啟動(dòng)時(shí)執(zhí)行
    @PostConstruct
    public void initBloomFilter() {
        // 判斷布隆過(guò)濾器是否存在
        Boolean exists = (Boolean) redisTemplate.execute((RedisCallback<Boolean>) connection -> 
            connection.exists(BLOOM_FILTER_NAME.getBytes()));
        
        if (Boolean.FALSE.equals(exists)) {
            // 創(chuàng)建布隆過(guò)濾器，預(yù)計(jì)元素量為100萬(wàn)，錯(cuò)誤率為0.01
            redisTemplate.execute((RedisCallback<Object>) connection -> 
                connection.execute("BF.RESERVE", 
                                  BLOOM_FILTER_NAME.getBytes(), 
                                  "0.01".getBytes(), 
                                  "1000000".getBytes()));
            
            // 加載所有商品ID到布隆過(guò)濾器
            List<Long> allProductIds = productMapper.getAllProductIds();
            for (Long id : allProductIds) {
                redisTemplate.execute((RedisCallback<Boolean>) connection -> 
                    connection.execute("BF.ADD", 
                                      BLOOM_FILTER_NAME.getBytes(), 
                                      id.toString().getBytes()) != 0);
            }
        }
    }
    
    @Override
    public Product getProductById(Long productId) {
        String cacheKey = CACHE_KEY_PREFIX + productId;
        
        // 1. 使用布隆過(guò)濾器檢查ID是否存在
        Boolean mayExist = (Boolean) redisTemplate.execute((RedisCallback<Boolean>) connection -> 
            connection.execute("BF.EXISTS", 
                             BLOOM_FILTER_NAME.getBytes(), 
                             productId.toString().getBytes()) != 0);
        
        // 如果布隆過(guò)濾器判斷不存在，則直接返回
        if (Boolean.FALSE.equals(mayExist)) {
            return null;
        }
        
        // 2. 查詢(xún)緩存
        String productJson = redisTemplate.opsForValue().get(cacheKey);
        if (productJson != null) {
            return JSON.parseObject(productJson, Product.class);
        }
        
        // 3. 查詢(xún)數(shù)據(jù)庫(kù)
        Product product = productMapper.selectById(productId);
        
        // 4. 更新緩存
        if (product != null) {
            redisTemplate.opsForValue().set(cacheKey, 
                                           JSON.toJSONString(product), 
                                           CACHE_EXPIRE_SECONDS, 
                                           TimeUnit.SECONDS);
        } else {
            // 布隆過(guò)濾器誤判，數(shù)據(jù)庫(kù)中不存在該商品
            // 可以考慮記錄這類(lèi)誤判情況，優(yōu)化布隆過(guò)濾器參數(shù)
            log.warn("Bloom filter false positive for productId: {}", productId);
        }
        
        return product;
    }
    
    // 當(dāng)新增商品時(shí)，需要將ID添加到布隆過(guò)濾器
    public void addProductToBloomFilter(Long productId) {
        redisTemplate.execute((RedisCallback<Boolean>) connection -> 
            connection.execute("BF.ADD", 
                             BLOOM_FILTER_NAME.getBytes(), 
                             productId.toString().getBytes()) != 0);
    }
}

@RestController
@RequestMapping("/api/user")
public class UserController {
    
    @Autowired
    private UserService userService;
    
    @GetMapping("/{userId}")
    public ResponseEntity<?> getUserById(@PathVariable String userId) {
        // 1. 基本格式校驗(yàn)
        if (!userId.matches("\d+")) {
            return ResponseEntity.badRequest().body("UserId must be numeric");
        }
        
        // 2. 基本邏輯校驗(yàn)
        long id = Long.parseLong(userId);
        if (id <= 0 || id > 100000000) {  // 假設(shè)ID范圍限制
            return ResponseEntity.badRequest().body("UserId out of valid range");
        }
        
        // 3. 調(diào)用業(yè)務(wù)服務(wù)
        User user = userService.getUserById(id);
        if (user == null) {
            return ResponseEntity.notFound().build();
        }
        
        return ResponseEntity.ok(user);
    }
}

@Service
public class UserServiceImpl implements UserService {
    
    // 白名單，只允許查詢(xún)這些ID前綴（舉例）
    private static final Set<String> ID_PREFIXES = Set.of("100", "200", "300");
    
    @Override
    public User getUserById(Long userId) {
        // 更復(fù)雜的業(yè)務(wù)規(guī)則校驗(yàn)
        String idStr = userId.toString();
        boolean valid = false;
        
        for (String prefix : ID_PREFIXES) {
            if (idStr.startsWith(prefix)) {
                valid = true;
                break;
            }
        }
        
        if (!valid) {
            log.warn("Attempt to access invalid user ID pattern: {}", userId);
            return null;
        }
        
        // 正常業(yè)務(wù)邏輯...
        return getUserFromCacheOrDb(userId);
    }
}

@Configuration
public class ResilienceConfig {
    
    @Bean
    public RateLimiterRegistry rateLimiterRegistry() {
        RateLimiterConfig config = RateLimiterConfig.custom()
            .limitRefreshPeriod(Duration.ofSeconds(1))
            .limitForPeriod(100)  // 每秒允許100個(gè)請(qǐng)求
            .timeoutDuration(Duration.ofMillis(25))
            .build();
        
        return RateLimiterRegistry.of(config);
    }
    
    @Bean
    public CircuitBreakerRegistry circuitBreakerRegistry() {
        CircuitBreakerConfig config = CircuitBreakerConfig.custom()
            .failureRateThreshold(50)  // 50%失敗率觸發(fā)熔斷
            .slidingWindowSize(100)    // 基于最近100次調(diào)用
            .minimumNumberOfCalls(10)  // 至少10次調(diào)用才會(huì)觸發(fā)熔斷
            .waitDurationInOpenState(Duration.ofSeconds(10)) // 熔斷后等待時(shí)間
            .build();
        
        return CircuitBreakerRegistry.of(config);
    }
}

@Service
public class ProductServiceWithResilience {

    private final ProductMapper productMapper;
    private final StringRedisTemplate redisTemplate;
    private final RateLimiter rateLimiter;
    private final CircuitBreaker circuitBreaker;
    
    public ProductServiceWithResilience(
            ProductMapper productMapper,
            StringRedisTemplate redisTemplate,
            RateLimiterRegistry rateLimiterRegistry,
            CircuitBreakerRegistry circuitBreakerRegistry) {
        this.productMapper = productMapper;
        this.redisTemplate = redisTemplate;
        this.rateLimiter = rateLimiterRegistry.rateLimiter("productService");
        this.circuitBreaker = circuitBreakerRegistry.circuitBreaker("productService");
    }
    
    public Product getProductById(Long productId) {
        // 1. 應(yīng)用限流器
        return rateLimiter.executeSupplier(() -> {
            // 2. 應(yīng)用熔斷器
            return circuitBreaker.executeSupplier(() -> {
                return doGetProduct(productId);
            });
        });
    }
    
    private Product doGetProduct(Long productId) {
        String cacheKey = "product:" + productId;
        
        // 查詢(xún)緩存
        String productJson = redisTemplate.opsForValue().get(cacheKey);
        if (productJson != null) {
            return JSON.parseObject(productJson, Product.class);
        }
        
        // 查詢(xún)數(shù)據(jù)庫(kù)
        Product product = productMapper.selectById(productId);
        
        // 更新緩存
        if (product != null) {
            redisTemplate.opsForValue().set(cacheKey, JSON.toJSONString(product), 1, TimeUnit.HOURS);
        } else {
            // 空值緩存，短期有效
            redisTemplate.opsForValue().set(cacheKey, "", 5, TimeUnit.MINUTES);
        }
        
        return product;
    }
    
    // 熔斷后的降級(jí)方法
    private Product fallbackMethod(Long productId, Throwable t) {
        log.warn("Circuit breaker triggered for productId: {}", productId, t);
        // 返回默認(rèn)商品或者從本地緩存獲取
        return new Product(productId, "Temporary Unavailable", 0.0);
    }
}

@Component
public class CacheWarmUpTask {
    
    @Autowired
    private ProductMapper productMapper;
    
    @Autowired
    private StringRedisTemplate redisTemplate;
    
    @Autowired
    private RedisBloomFilter bloomFilter;
    
    // 系統(tǒng)啟動(dòng)時(shí)執(zhí)行緩存預(yù)熱
    @PostConstruct
    public void warmUpCacheOnStartup() {
        // 異步執(zhí)行預(yù)熱任務(wù)，避免阻塞應(yīng)用啟動(dòng)
        CompletableFuture.runAsync(this::warmUpHotProducts);
    }
    
    // 每天凌晨2點(diǎn)刷新熱門(mén)商品緩存
    @Scheduled(cron = "0 0 2 * * ?")
    public void scheduledWarmUp() {
        warmUpHotProducts();
    }
    
    private void warmUpHotProducts() {
        log.info("開(kāi)始預(yù)熱商品緩存...");
        long startTime = System.currentTimeMillis();
        
        try {
            // 1. 獲取熱門(mén)商品列表（例如銷(xiāo)量TOP5000）
            List<Product> hotProducts = productMapper.findHotProducts(5000);
            
            // 2. 更新緩存和布隆過(guò)濾器
            for (Product product : hotProducts) {
                String cacheKey = "product:" + product.getId();
                redisTemplate.opsForValue().set(
                    cacheKey, 
                    JSON.toJSONString(product), 
                    6, TimeUnit.HOURS
                );
                
                // 更新布隆過(guò)濾器
                bloomFilter.add("product_filter", product.getId().toString());
            }
            
            // 3. 同時(shí)預(yù)熱一些必要的聚合信息
            List<Category> categories = productMapper.findAllCategories();
            for (Category category : categories) {
                String cacheKey = "category:" + category.getId();
                List<Long> productIds = productMapper.findProductIdsByCategory(category.getId());
                redisTemplate.opsForValue().set(
                    cacheKey,
                    JSON.toJSONString(productIds),
                    12, TimeUnit.HOURS
                );
            }
            
            long duration = System.currentTimeMillis() - startTime;
            log.info("緩存預(yù)熱完成，耗時(shí)：{}ms，預(yù)熱商品數(shù)量：{}", duration, hotProducts.size());
            
        } catch (Exception e) {
            log.error("緩存預(yù)熱失敗", e);
        }
    }
}

// 1. 網(wǎng)關(guān)層過(guò)濾（使用Spring Cloud Gateway）
@Configuration
public class GatewayFilterConfig {
    
    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
            .route("product_route", r -> r.path("/api/product/**")
                // 路徑格式驗(yàn)證
                .and().predicate(exchange -> {
                    String path = exchange.getRequest().getURI().getPath();
                    // 檢查product/{id}路徑，確保id為數(shù)字
                    if (path.matches("/api/product/\d+")) {
                        String id = path.substring(path.lastIndexOf('/') + 1);
                        long productId = Long.parseLong(id);
                        return productId > 0 && productId < 10000000; // 合理范圍檢查
                    }
                    return true;
                })
                // 限流過(guò)濾
                .filters(f -> f.requestRateLimiter()
                    .rateLimiter(RedisRateLimiter.class, c -> c.setReplenishRate(10).setBurstCapacity(20))
                    .and()
                    .circuitBreaker(c -> c.setName("productCB").setFallbackUri("forward:/fallback"))
                )
                .uri("lb://product-service")
            )
            .build();
    }
}

// 2. 應(yīng)用層過(guò)濾（Resilience4j + Bloom Filter）
@Service
public class ProductServiceImpl implements ProductService {
    
    private final StringRedisTemplate redisTemplate;
    private final ProductMapper productMapper;
    private final BloomFilter<String> localBloomFilter;
    private final RateLimiter rateLimiter;
    private final CircuitBreaker circuitBreaker;
    
    @Value("${cache.product.expire-seconds:3600}")
    private int cacheExpireSeconds;
    
    // 構(gòu)造函數(shù)注入...
    
    @PostConstruct
    public void initLocalFilter() {
        // 創(chuàng)建本地布隆過(guò)濾器作為二級(jí)保護(hù)
        localBloomFilter = BloomFilter.create(
            Funnels.stringFunnel(StandardCharsets.UTF_8),
            1000000,  // 預(yù)期元素?cái)?shù)量
            0.001     // 誤判率
        );
        
        // 初始化本地布隆過(guò)濾器數(shù)據(jù)
        List<String> allProductIds = productMapper.getAllProductIdsAsString();
        for (String id : allProductIds) {
            localBloomFilter.put(id);
        }
    }
    
    @Override
    public Product getProductById(Long productId) {
        String productIdStr = productId.toString();
        
        // 1. 本地布隆過(guò)濾器預(yù)檢
        if (!localBloomFilter.mightContain(productIdStr)) {
            log.info("Product filtered by local bloom filter: {}", productId);
            return null;
        }
        
        // 2. Redis布隆過(guò)濾器二次檢查
        Boolean mayExist = redisTemplate.execute(
            (RedisCallback<Boolean>) connection -> connection.execute(
                "BF.EXISTS", 
                "product_filter".getBytes(), 
                productIdStr.getBytes()
            ) != 0
        );
        
        if (Boolean.FALSE.equals(mayExist)) {
            log.info("Product filtered by Redis bloom filter: {}", productId);
            return null;
        }
        
        // 3. 應(yīng)用限流和熔斷保護(hù)
        try {
            return rateLimiter.executeSupplier(() -> 
                circuitBreaker.executeSupplier(() -> {
                    return getProductFromCacheOrDb(productId);
                })
            );
        } catch (RequestNotPermitted e) {
            log.warn("Request rate limited for product: {}", productId);
            throw new ServiceException("Service is busy, please try again later");
        } catch (CallNotPermittedException e) {
            log.warn("Circuit breaker open for product queries");
            throw new ServiceException("Service is temporarily unavailable");
        }
    }
    
    private Product getProductFromCacheOrDb(Long productId) {
        String cacheKey = "product:" + productId;
        
        // 4. 查詢(xún)緩存
        String cachedValue = redisTemplate.opsForValue().get(cacheKey);
        
        if (cachedValue != null) {
            // 處理空值緩存情況
            if (cachedValue.isEmpty()) {
                return null;
            }
            return JSON.parseObject(cachedValue, Product.class);
        }
        
        // 5. 查詢(xún)數(shù)據(jù)庫(kù)（加入DB保護(hù)）
        Product product = null;
        try {
            product = productMapper.selectById(productId);
        } catch (Exception e) {
            log.error("Database error when querying product: {}", productId, e);
            throw new ServiceException("System error, please try again later");
        }
        
        // 6. 更新緩存（空值也緩存）
        if (product != null) {
            redisTemplate.opsForValue().set(
                cacheKey, 
                JSON.toJSONString(product),
                cacheExpireSeconds,
                TimeUnit.SECONDS
            );
            
            // 確保布隆過(guò)濾器包含此ID
            redisTemplate.execute(
                (RedisCallback<Boolean>) connection -> connection.execute(
                    "BF.ADD", 
                    "product_filter".getBytes(), 
                    productId.toString().getBytes()
                ) != 0
            );
            
            localBloomFilter.put(productId.toString());
        } else {
            // 緩存空值，短時(shí)間過(guò)期
            redisTemplate.opsForValue().set(
                cacheKey,
                "",
                60, // 空值短期緩存
                TimeUnit.SECONDS
            );
        }
        
        return product;
    }
}