public class RedisConstants {
    // 验证码相关
    public static final String LOGIN_CODE_KEY = "login:code:";
    public static final Long LOGIN_CODE_TTL = 2L; // 验证码有效期2分钟
    
    // 用户登录相关
    public static final String LOGIN_USER_KEY = "login:token:";
    public static final Long LOGIN_USER_TTL = 30L; // 用户登录有效期30分钟
    
    // 用户签到相关
    public static final String USER_SIGN_KEY = "sign:";
    
    // 商户信息相关
    public static final String CACHE_SHOP_KEY = "cache:shop:";
    public static final Long CACHE_SHOP_TTL = 30L; // 商户信息缓存30分钟
    
    // 互斥锁相关
    public static final String LOCK_SHOP_KEY = "lock:shop:";
    public static final Long LOCK_SHOP_TTL = 10L; // 锁有效期10秒
}

@Component
public class LoginInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, 
                           HttpServletResponse response, 
                           Object handler) throws Exception {
        // 1. 判断是否需要拦截（ThreadLocal中是否有用户）
        if (UserHolder.getUser() == null) {
            // 2. 没有登录，设置状态码
            response.setStatus(401);
            return false; // 拦截
        }
        
        // 3. 有用户，放行
        return true;
    }
}

@Configuration
public class MvcConfig implements WebMvcConfigurer {

    @Resource
    private RefreshTokenInterceptor refreshTokenInterceptor;
    
    @Resource
    private LoginInterceptor loginInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 1. 刷新拦截器 - 拦截所有路径，用于刷新token
        registry.addInterceptor(refreshTokenInterceptor)
                .addPathPatterns("/**")
                .order(0); // 最高优先级
                
        // 2. 登录拦截器 - 只拦截需要登录的路径
        registry.addInterceptor(loginInterceptor)
                .excludePathPatterns(
                    "/user/code",
                    "/user/login", 
                    "/blog/hot",
                    "/shop/**",
                    "/shop-type/**",
                    "/upload/**",
                    "/voucher/**"
                )
                .order(1); // 第二优先级
    }
}

@Autowired
private RedisTemplate<String, Object> redisTemplate;

// 缓存操作
public void setCache(String key, Object value, long timeout) {
    redisTemplate.opsForValue().set(key, value, timeout, TimeUnit.MINUTES);
}

public Object getCache(String key) {
    return redisTemplate.opsForValue().get(key);
}

// 本地缓存
private static final Map<String, Object> localCache = new ConcurrentHashMap<>();

// Redis缓存
@Autowired
private RedisTemplate<String, Object> redisTemplate;

@RestController
@RequestMapping("/shop")
public class ShopController {

    @GetMapping("/{id}")
    public Result queryShop(@PathVariable("id") Long id) {
        // 调用Service层的缓存查询方法
        return shopService.queryShopById(id);
    }
}

public class RedisConstants {
    public static final String CACHE_SHOP_KEY = "cache:shop:";
    public static final Long CACHE_SHOP_TTL = 30L; // 30分钟
}

// 业务数据缓存 - 30分钟
stringRedisTemplate.opsForValue().set(key, value, 30, TimeUnit.MINUTES);

// 热点数据缓存 - 1小时  
stringRedisTemplate.opsForValue().set(key, value, 1, TimeUnit.HOURS);

// 配置数据缓存 - 24小时
stringRedisTemplate.opsForValue().set(key, value, 24, TimeUnit.HOURS);

// 更新商户信息
public Result updateShop(Shop shop) {
    Long id = shop.getId();
    
    // 1. 更新数据库
    updateById(shop);
    
    // 2. 删除缓存（主动更新）
    String key = CACHE_SHOP_KEY + id;
    stringRedisTemplate.delete(key);
    
    return Result.ok();
}

@Transactional
public Result updateShop(Shop shop) {
    try {
        // 1. 更新数据库
        shopMapper.updateById(shop);
        
        // 2. 删除缓存
        stringRedisTemplate.delete(CACHE_SHOP_KEY + shop.getId());
        
        return Result.ok();
    } catch (Exception e) {
        // 事务回滚，数据库和缓存保持一致
        throw new RuntimeException("更新失败", e);
    }
}

@Override
@Transactional
public Result updateShop(Shop shop) {
    Long id = shop.getId();
    
    // 1. 参数校验
    if (id == null) {
        return Result.fail("店铺id不能为空！");
    }
    
    // 2. 更新数据库
    boolean updated = updateById(shop);
    if (!updated) {
        return Result.fail("店铺更新失败！");
    }
    
    // 3. 删除缓存（保证数据一致性）
    String key = CACHE_SHOP_KEY + id;
    stringRedisTemplate.delete(key);
    
    // 4. 返回成功
    return Result.ok();
}

@RestController
@RequestMapping("/shop")
public class ShopController {

    @GetMapping("/{id}")
    public Result queryShop(@PathVariable("id") Long id) {
        // 查询商户（带缓存）
        return shopService.queryShopById(id);
    }
    
    @PutMapping
    public Result updateShop(@RequestBody Shop shop) {
        // 更新商户（保证缓存一致性）
        return shopService.updateShop(shop);
    }
}

@Component
public class BloomFilterService {
    
    @Resource
    private StringRedisTemplate stringRedisTemplate;
    
    // 初始化布隆过滤器
    public void initBloomFilter() {
        // 将所有商品ID添加到布隆过滤器
        List<Long> allShopIds = shopMapper.selectAllIds();
        for (Long id : allShopIds) {
            addToBloomFilter("shop:bloom:", id);
        }
    }
    
    // 添加到布隆过滤器
    private void addToBloomFilter(String key, Long id) {
        int[] offset = getBitOffset(id);
        for (int i : offset) {
            stringRedisTemplate.opsForValue().setBit(key, i, true);
        }
    }
    
    // 判断是否存在
    public boolean mightExist(String key, Long id) {
        int[] offset = getBitOffset(id);
        for (int i : offset) {
            if (!stringRedisTemplate.opsForValue().getBit(key, i)) {
                return false;  // 一定不存在
            }
        }
        return true;  // 可能存在（存在误判）
    }
}

@Component
public class CachePenetrationProtection {
    
    @Resource
    private StringRedisTemplate stringRedisTemplate;
    
    /**
     * 安全的缓存查询方法
     * @param key 缓存key
     * @param type 返回类型
     * @param dbFallback 数据库查询函数
     * @param ttl 过期时间
     * @param unit 时间单位
     * @return 查询结果
     */
    public <T> T safeQuery(String key, Class<T> type, 
                          Supplier<T> dbFallback, 
                          Long ttl, TimeUnit unit) {
        // 1. 查询缓存
        String json = stringRedisTemplate.opsForValue().get(key);
        
        // 2. 命中缓存
        if (StrUtil.isNotBlank(json)) {
            if ("null".equals(json)) {
                return null;  // 缓存的空值
            }
            return JSONUtil.toBean(json, type);
        }
        
        // 3. 查询数据库
        T result = dbFallback.get();
        
        // 4. 缓存结果（包括空值）
        if (result == null) {
            stringRedisTemplate.opsForValue().set(key, "", 2, TimeUnit.MINUTES);
        } else {
            stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(result), ttl, unit);
        }
        
        return result;
    }
}

@RestController
@RequestMapping("/shop")
public class ShopController {
    
    @GetMapping("/{id}")
    public Result queryShop(@PathVariable("id") String idStr) {
        // 1. 参数格式校验（第一层防护）
        if (!idStr.matches("\\d+")) {
            return Result.fail("店铺ID格式错误！");
        }
        
        Long id = Long.valueOf(idStr);
        
        // 2. ID范围校验（第二层防护）
        if (id > 1000000) {  // 假设最大ID为100万
            return Result.fail("店铺ID超出范围！");
        }
        
        // 3. 调用带缓存穿透防护的Service方法
        return shopService.queryShopById(id);
    }
}

@SentinelResource(value = "getShop", 
    blockHandler = "handleBlock", 
    fallback = "handleFallback")
public Shop getShop(Long id) {
    // 正常业务逻辑
    return shopService.getById(id);
}

// 限流处理
public Shop handleBlock(Long id, BlockException ex) {
    log.warn("接口被限流: {}", id);
    return getDefaultShop(id); // 返回默认值或缓存数据
}

// 降级处理
public Shop handleFallback(Long id, Throwable ex) {
    log.error("接口降级: {}", id, ex);
    return getDefaultShop(id); // 返回兜底数据
}

// 本地缓存配置
LoadingCache<String, Shop> localCache = Caffeine.newBuilder()
    .maximumSize(10000)
    .expireAfterWrite(5, TimeUnit.MINUTES)
    .build(key -> {
        // 缓存未命中时从Redis加载
        return getFromRedis(key);
    });

public Shop queryShop(Long id) {
    // 优先查询本地缓存
    return localCache.get(CACHE_SHOP_KEY + id);
}

@Data
public class RedisData {
    private LocalDateTime expireTime;  // 逻辑过期时间
    private Object data;                 // 实际数据
}

private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);

public Shop queryWithLogicalExpire(Long id) {
    String key = CACHE_SHOP_KEY + id;
    
    // 1. 查询缓存
    String json = stringRedisTemplate.opsForValue().get(key);
    if (StrUtil.isBlank(json)) {
        return null; // 缓存未命中直接返回
    }
    
    // 2. 反序列化数据
    RedisData redisData = JSONUtil.toBean(json, RedisData.class);
    Shop shop = JSONUtil.toBean((JSONObject) redisData.getData(), Shop.class);
    LocalDateTime expireTime = redisData.getExpireTime();
    
    // 3. 判断是否过期
    if (expireTime.isAfter(LocalDateTime.now())) {
        // 3.1 未过期，直接返回
        return shop;
    }
    
    // 3.2 已过期，需要缓存重建
    String lockKey = LOCK_SHOP_KEY + id;
    boolean isLock = tryLock(lockKey);
    
    if (isLock) {
        // 4. 获取锁成功，异步重建缓存
        CACHE_REBUILD_EXECUTOR.submit(() -> {
            try {
                // 重建缓存
                saveShop2Redis(id, 20L); // 20分钟逻辑过期时间
            } catch (Exception e) {
                log.error("缓存重建失败", e);
            } finally {
                unlock(lockKey);
            }
        });
    }
    
    // 5. 返回旧数据
    return shop;
}

private void saveShop2Redis(Long id, Long expireSeconds) {
    // 查询数据库
    Shop shop = getById(id);
    
    // 封装逻辑过期时间
    RedisData redisData = new RedisData();
    redisData.setData(shop);
    redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds));
    
    // 写入Redis（不设TTL）
    stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(redisData));
}