145｜多级缓存架构：本地缓存、分布式缓存、CDN 的一致性与失效传播

CPU 寄存器 (0.3ns)
  → L1 Cache (1ns, 32KB)
    → L2 Cache (4ns, 256KB)
      → L3 Cache (12ns, 8MB)
        → 主内存 (100ns, GB级)
          → SSD/磁盘 (100μs~10ms, TB级)

          ┌──────────────┐
          │   CDN 缓存    │  ← 边缘节点，离用户最近（10ms）
          ├──────────────┤
          │  反向代理缓存  │  ← Nginx/Varnish（1~5ms）
          ├──────────────┤
          │  本地缓存     │  ← Caffeine/Guava（μs级）
          ├──────────────┤
          │  分布式缓存   │  ← Redis Cluster（1ms）
          ├──────────────┤
          │  数据库       │  ← MySQL（10~100ms）
          └──────────────┘

Cache<String, Product> cache = Caffeine.newBuilder()
    .maximumSize(10_000)               // 最大条目数
    .expireAfterWrite(5, TimeUnit.MINUTES)  // 写入后过期
    .expireAfterAccess(1, TimeUnit.MINUTES) // 访问后过期
    .recordStats()                     // 开启统计
    .build();

Product product = cache.get("product:1001", key -> {
    // 缓存未命中，从数据库加载
    return productDao.findById(1001);
});

写入 → Window Cache (1% 容量，LRU)
         ↓ 晋升
       Main Cache (99% 容量，SLRU)
         ↓ 淘汰判断
       TinyLFU 过滤器 (Count-Min Sketch)

LoadingCache<String, Product> cache = CacheBuilder.newBuilder()
    .maximumSize(10_000)
    .expireAfterWrite(5, TimeUnit.MINUTES)
    .build(new CacheLoader<String, Product>() {
        @Override
        public Product load(String key) {
            return productDao.findById(key);
        }
    });

CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder()
    .withCache("productCache",
        CacheConfigurationBuilder.newCacheConfigurationBuilder(
            String.class, Product.class,
            ResourcePoolsBuilder.newResourcePoolsBuilder()
                .heap(1000, EntryUnit.ENTRIES)     // 堆内 1000 条
                .offheap(10, MemoryUnit.MB)         // 堆外 10MB
                .disk(100, MemoryUnit.MB, true)     // 磁盘 100MB
        )
        .withExpiry(ExpiryPolicyBuilder.timeToLiveExpiration(Duration.ofMinutes(5)))
    ).build(true);

数据更新 → 发送 MQ 消息 → 所有节点消费 → 删除本地缓存

数据更新 → 不主动通知 → 等 TTL 自然过期

Product product = localCache.get(key);
if (product == null || product.getVersion() < redis.getVersion(key)) {
    product = productDao.findById(id);
    localCache.put(key, product);
}

┌──────────────────────────────────────────────────┐
│                   Redis Cluster                   │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐          │
│  │ Master 1│  │ Master 2│  │ Master 3│          │
│  │Slot 0-5K│  │Slot 5K-10K│ │Slot 10K-16K│        │
│  └────┬────┘  └────┬────┘  └────┬────┘          │
│       │            │            │                 │
│  ┌────┴────┐  ┌────┴────┐  ┌────┴────┐          │
│  │ Slave 1 │  │ Slave 2 │  │ Slave 3 │          │
│  └─────────┘  └─────────┘  └─────────┘          │
└──────────────────────────────────────────────────┘

客户端 A → 更新 Redis Master → 异步复制到 Slave
客户端 B → 在 Slave 同步完成前读取 → 读到旧数据

读：先读缓存 → 命中返回 → 未命中读 DB → 写缓存 → 返回
写：更新 DB → 删除缓存（不是更新缓存！）

public void updateProduct(Product product) {
    // 第一步：先删除缓存
    redis.delete("product:" + product.getId());
    
    // 第二步：更新数据库
    productDao.update(product);
    
    // 第三步：延迟 N 毫秒后再删一次
    scheduler.schedule(() -> {
        redis.delete("product:" + product.getId());
    }, 500, TimeUnit.MILLISECONDS);
}

应用更新 DB → MySQL 生成 binlog → Canal 监听 binlog → 解析 → 删除/更新 Redis

用户（北京）→ DNS 解析 → 北京 CDN 节点 → 命中/未命中
                              ↓ 未命中
                         回源到源站（杭州）

Cache-Control: max-age=3600        # 缓存 1 小时
Cache-Control: s-maxage=600        # CDN 缓存 10 分钟（覆盖 max-age）
Cache-Control: no-cache            # 可缓存但必须验证
Cache-Control: no-store            # 完全不缓存
Cache-Control: public              # 可被 CDN 和浏览器缓存
Cache-Control: private             # 仅浏览器缓存

请求 → CDN 有缓存（已过期）→ 带 If-None-Match/If-Modified-Since 回源
     → 源站返回 304 Not Modified → CDN 继续使用缓存
     → 源站返回 200 + 新内容 → CDN 更新缓存

POST /cdn/refresh
{"urls": ["https://example.com/product/1001.html"]}

POST /cdn/refresh
{"dirs": ["https://example.com/products/"]}

用户请求
  ↓
CDN 层（静态资源/页面片段）
  ├── 命中 → 直接返回（10ms）
  └── 未命中 → 回源到 Nginx
                ↓
          Nginx 反向代理缓存层
            ├── 命中 → 返回（2ms）
            └── 未命中 → 转发到应用服务器
                          ↓
                    应用服务器本地缓存（Caffeine）
                      ├── 命中 → 返回（1μs）
                      └── 未命中 → 查询 Redis
                                    ↓
                              Redis 分布式缓存
                                ├── 命中 → 返回（1ms）+ 写回本地缓存
                                └── 未命中 → 查询 MySQL
                                              ↓
                                        加载数据 → 写回 Redis → 写回本地缓存 → 返回

未命中 → 查 DB → 写缓存 → 返回

未命中 → 返回旧值（如有）→ 异步查 DB → 写缓存

LoadingCache<String, Product> cache = Caffeine.newBuilder()
    .refreshAfterWrite(4, TimeUnit.MINUTES)  // 4 分钟后异步刷新
    .build(key -> productDao.findById(key));

// 应用启动时预热热点数据
@PostConstruct
public void warmUp() {
    List<String> hotKeys = hotKeyDetector.getTopK(1000);
    for (String key : hotKeys) {
        String value = redis.get(key);
        if (value != null) {
            localCache.put(key, value);
        }
    }
}

DB 更新 (t0)
  → Redis 删除 (t0 + 1ms)
    → 本地缓存 TTL 过期 (t0 + 5min)
      → CDN 刷新 (t0 + 1~5min)
        → 浏览器缓存过期 (t0 + 1h)

CDN：缓存整个页面 HTML（粗粒度）
Nginx：缓存页面片段（中粒度）
本地缓存：缓存 Java 对象（细粒度）
Redis：缓存数据库行或聚合数据（中粒度）

时间线：
T1: Node A 更新 DB（version=2），删除 Redis
T2: Node B 更新 DB（version=3），删除 Redis
T3: Node A 的本地缓存过期，从 DB 读到 version=3，写入 Redis → 正确
T4: Node C 的本地缓存过期，从 DB 读到 version=3，写入 Redis → 正确

                    ┌─────────────────────────────────────┐
                    │          一致性策略选择矩阵           │
                    ├──────────────┬──────────┬───────────┤
                    │   策略        │ 一致性   │ 复杂度    │
                    ├──────────────┼──────────┼───────────┤
                    │ TTL 过期      │ ★☆☆☆☆   │ ★☆☆☆☆    │
                    │ 主动失效      │ ★★★☆☆   │ ★★★☆☆    │
                    │ 版本号校验    │ ★★★★☆   │ ★★★☆☆    │
                    │ Binlog 订阅   │ ★★★★☆   │ ★★★★☆    │
                    │ 分布式事务    │ ★★★★★   │ ★★★★★    │
                    └──────────────┴──────────┴───────────┘

本地缓存：TTL（5~10min）+ 主动失效（MQ 广播）
Redis：Cache Aside + 延迟双删 + Binlog 订阅（最终一致）
CDN：URL 刷新 + 版本化 URL（/app.v2.js 而非 /app.js）

数据变更（DB）
  ↓
Canal 监听 binlog
  ↓
失效消息发送到 MQ（Kafka/RocketMQ）
  ↓
┌─────────────────────────────────────┐
│  消费者组 A：删除 Redis 缓存         │
│  消费者组 B：广播本地缓存失效事件     │
│  消费者组 C：调用 CDN 刷新 API       │
└─────────────────────────────────────┘

旧方案：/product.js → 更新后刷新 CDN → 等待生效（1~5min）
新方案：/product.v123.js → 更新后发布 /product.v124.js → 零等待

监控指标：
├── 缓存命中率（按层级）：CDN 命中率、Redis 命中率、本地缓存命中率
├── 失效传播延迟：从 DB 更新到各层缓存生效的时间差
├── 失效消息积压：MQ 消费者 lag
├── 缓存穿透率：到达 DB 的请求比例
└── 不一致检测：采样对比缓存值 vs DB 值

┌──────────────────────────────────────────────────────────┐
│                      客户端请求                            │
└───────────────────────┬──────────────────────────────────┘
                        ↓
┌──────────────────────────────────────────────────────────┐
│  CDN 层                                                  │
│  - 静态资源：版本化 URL（/app.a1b2c3.js）                 │
│  - 半静态页面：Cache-Control: s-maxage=600               │
└───────────────────────┬──────────────────────────────────┘
                        ↓
┌──────────────────────────────────────────────────────────┐
│  网关层（Nginx + Lua）                                    │
│  - 页面片段缓存：proxy_cache                             │
│  - 限流降级：缓存兜底                                     │
└───────────────────────┬──────────────────────────────────┘
                        ↓
┌──────────────────────────────────────────────────────────┐
│  应用层                                                  │
│  ┌────────────────────────────────────────────┐          │
│  │  MultiLevelCache（多级缓存抽象）            │          │
│  │  ┌──────────┐  ┌──────────┐  ┌──────────┐ │          │
│  │  │ L1: 本地  │  │ L2: Redis│  │ L3: DB   │ │          │
│  │  │ Caffeine │→ │ Cluster  │→ │  MySQL   │ │          │
│  │  └──────────┘  └──────────┘  └──────────┘ │          │
│  └────────────────────────────────────────────┘          │
│  ┌────────────────────────────────────────────┐          │
│  │  CacheConsistencyManager（一致性管理）      │          │
│  │  - 失效广播（MQ Consumer）                  │          │
│  │  - 版本号管理                               │          │
│  │  - 热点发现与预热                           │          │
│  └────────────────────────────────────────────┘          │
└──────────────────────────────────────────────────────────┘

public class MultiLevelCache<K, V> {
    
    private final Cache<K, V> localCache;      // L1: Caffeine
    private final RedisTemplate<String, V> redis;  // L2: Redis
    private final CacheLoader<K, V> dbLoader;  // L3: DB
    
    public V get(K key) {
        // L1: 本地缓存
        V value = localCache.getIfPresent(key);
        if (value != null) {
            metrics.recordHit("L1");
            return value;
        }
        
        // L2: Redis
        String redisKey = buildRedisKey(key);
        value = redis.opsForValue().get(redisKey);
        if (value != null) {
            metrics.recordHit("L2");
            localCache.put(key, value);  // 回填 L1
            return value;
        }
        
        // L3: Database
        metrics.recordHit("L3");
        value = dbLoader.load(key);
        if (value != null) {
            redis.opsForValue().set(redisKey, value, 
                Duration.ofMinutes(30));  // 回填 L2
            localCache.put(key, value);   // 回填 L1
        }
        return value;
    }
    
    public void evict(K key) {
        localCache.invalidate(key);
        redis.delete(buildRedisKey(key));
    }
}

@RocketMQMessageListener(topic = "cache-invalidation", consumerGroup = "cache-invalidation-group")
public class CacheInvalidationConsumer implements RocketMQListener<InvalidationMessage> {
    
    @Override
    public void onMessage(InvalidationMessage msg) {
        String cacheKey = msg.getCacheKey();
        InvalidationScope scope = msg.getScope();
        
        switch (scope) {
            case LOCAL_ONLY:
                localCache.invalidate(cacheKey);
                break;
            case REDIS_ONLY:
                redis.delete(cacheKey);
                break;
            case ALL:
                localCache.invalidate(cacheKey);
                redis.delete(cacheKey);
                break;
        }
    }
}

@Component
public class CacheMetrics {
    
    private final MeterRegistry registry;
    
    // 各层命中率
    private final Counter l1Hits, l2Hits, l3Hits, l1Misses, l2Misses, l3Misses;
    
    // 失效传播延迟
    private final Timer invalidationPropagationLatency;
    
    public void recordHit(String level) {
        switch (level) {
            case "L1": l1Hits.increment(); break;
            case "L2": l2Hits.increment(); break;
            case "L3": l3Hits.increment(); break;
        }
    }
    
    @Scheduled(fixedRate = 60000)
    public void reportMetrics() {
        double l1Rate = l1Hits.count() / (l1Hits.count() + l1Misses.count());
        double l2Rate = l2Hits.count() / (l2Hits.count() + l2Misses.count());
        
        log.info("Cache hit rates - L1: {:.2%}, L2: {:.2%}", l1Rate, l2Rate);
        
        // 告警：L1 命中率低于 80%
        if (l1Rate < 0.8) {
            alertService.send("L1 缓存命中率异常: {:.2%}", l1Rate);
        }
    }
}