🚀 缓存策略

🏗️ 四级缓存金字塔

     ┌─────────────────────────────────────────┐
     │  L1: 本地缓存 (Caffeine / Guava Cache)  │  纳秒级 | < 1GB
     │  JVM堆内，最快，容量有限                  │
     ├─────────────────────────────────────────┤
     │  L2: 分布式缓存 (Redis / Memcached)      │  毫秒级 | TB级
     │  跨实例共享，容量可按需扩展               │
     ├─────────────────────────────────────────┤
     │  L3: 数据库缓存 (MySQL Buffer Pool)      │  毫秒级 | 取决于内存
     │  InnoDB缓冲池，热数据自动缓存             │
     ├─────────────────────────────────────────┤
     │  L4: 本地磁盘 / CDN                       │  毫秒-秒 | PB级
     │  静态资源、不变数据                       │
     └─────────────────────────────────────────┘

     缓存命中流程: L1 → L2 → L3 → 源数据
     每层Miss时回源加载，并回填上层缓存

📊 各级缓存技术选型

🗂️ 数据结构选择指南

⚙️ Redis 关键配置优化

🔗 集群方案对比

📐 六种缓存一致性方案对比

📋 标准 Cache-Aside 实现

// 读取：缓存优先
public Order getOrder(Long id) {
    String key = "order:" + id;
    Order order = redis.get(key);
    if (order != null) return order;

    // 缓存未命中，查DB
    order = db.findById(id);
    if (order != null) {
        redis.setex(key, 3600, order);  // 回填缓存，设置过期时间
    }
    return order;
}

// 写入：先更新DB，再删除缓存
@Transactional
public void updateOrder(Order order) {
    db.update(order);                  // 1. 先更新数据库
    redis.del("order:" + order.id);    // 2. 再删除缓存
}

// 删除操作双删策略（高并发优化）
@Transactional
public void deleteOrder(Long id) {
    redis.del("order:" + id);          // 1. 先删缓存
    db.delete(id);                      // 2. 更新DB
    Thread.sleep(500);                  // 3. 等待其他并发读完成
    redis.del("order:" + id);          // 4. 二次删除，防止并发写导致的脏缓存
}

⚠️ 三大问题对比总览

🛡️ 穿透防护三层防线

💻 布隆过滤器实现示例

// 使用 RedisBloom 模块
// BF.RESERVE product_filter 0.01 10000000   // 误判率1%，预计1000万元素

public Product getProduct(Long id) {
    // 1. 布隆过滤器检查
    if (!redis.bfExists("product_filter", String.valueOf(id))) {
        return null;  // 一定不存在，直接返回
    }
    // 2. 查缓存
    Product product = redis.get("product:" + id);
    if (product != null) return product;
    // 3. 查DB
    product = db.findById(id);
    if (product != null) {
        redis.setex("product:" + id, 3600, product);
    } else {
        // 4. 缓存空值（防止布隆过滤器误判导致穿透）
        redis.setex("product:" + id, 60, "NULL");
    }
    return product;
}

🔐 互斥锁方案（Redis SETNX）

public Product getHotProduct(Long id) {
    String key = "hot:product:" + id;
    Product product = redis.get(key);
    if (product != null) return product;

    // 加互斥锁，只让一个线程去加载
    String lockKey = "lock:product:" + id;
    try {
        if (redis.setnx(lockKey, "1", 10)) {  // 获取锁，10秒过期
            // 双重检查
            product = redis.get(key);
            if (product != null) return product;

            product = db.findById(id);
            redis.setex(key, 3600, product);
        } else {
            // 未获取锁，短暂等待后重试
            Thread.sleep(100);
            return getHotProduct(id);  // 递归重试
        }
    } finally {
        redis.del(lockKey);
    }
    return product;
}

🛡️ 雪崩防护四层体系

💻 随机TTL + 多级缓存实现

// Caffeine 本地缓存配置
Cache<String, Object> localCache = Caffeine.newBuilder()
    .maximumSize(10000)
    .expireAfterWrite(30, TimeUnit.SECONDS)
    .recordStats()
    .build();

public User getWithMultiLevelCache(Long userId) {
    String key = "user:" + userId;

    // L1: 本地缓存
    User user = localCache.getIfPresent(key);
    if (user != null) return user;

    try {
        // L2: Redis分布式缓存
        user = redis.get(key);
        if (user != null) {
            localCache.put(key, user);  // 回填本地缓存
            return user;
        }
    } catch (Exception e) {
        // Redis故障，尝试降级
        log.warn("Redis unavailable, using fallback", e);
        return getFallbackUser(userId);
    }

    // L3: 数据库
    user = db.findById(userId);
    if (user != null) {
        // 设置随机过期时间，避免雪崩
        int ttl = 3600 + ThreadLocalRandom.current().nextInt(600);
        redis.setex(key, ttl, user);
        localCache.put(key, user);
    }
    return user;
}