引言

在高并发的互联网应用中，缓存是提升系统性能的重要手段。但你是否遇到过这样的场景：某个热点Key突然失效，导致大量请求直接打到数据库，瞬间拖垮整个系统？这就是典型的缓存雪崩问题。

更糟糕的是，当用户查询一个不存在的数据时，请求会穿透缓存直达数据库，如果这种请求量很大，同样会把数据库打垮。这就是缓存穿透问题。

今天，我将分享一套完整的SpringBoot缓存防护方案，通过本地缓存、预热机制和空值兜底等技术手段，提前防御这些风险。

问题分析

缓存穿透的典型场景

想象这样一个电商系统：

• 商品详情页访问量巨大
• 某个商品突然下架（数据不存在）
• 大量用户继续访问这个商品ID
• 每次请求都穿透缓存查询数据库
• 数据库连接池耗尽，系统响应超时

缓存雪崩的危险信号

• 热点商品缓存同时过期
• 瞬间大量请求涌入数据库
• 数据库CPU使用率达到100%
• 系统整体响应时间急剧上升
• 用户体验严重下降

解决方案设计

核心架构思路

我设计了一套三层防护体系：

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│   布隆过滤器    │───▶│   本地缓存层    │───▶│   分布式缓存    │
│  (快速拦截)     │    │  (Caffeine)     │    │   (Redis)       │
└─────────────────┘    └─────────────────┘    └─────────────────┘
         │                       │                       │
         ▼                       ▼                       ▼
    不存在直接返回         缓存命中快速返回        数据库查询

技术选型考虑

为什么选择Caffeine作为本地缓存？

• 高性能：接近内存访问速度
• 丰富的淘汰策略
• 良好的统计功能
• 与Spring Boot集成简单

为什么需要布隆过滤器？

• 空间效率极高
• 查询速度极快
• 能够快速判断Key不存在
• 避免不必要的缓存和数据库查询

核心实现详解

1. 布隆过滤器防护层

@Service
public class BloomFilterService {
    
    private final BloomFilter<String> localBloomFilter;
    
    public boolean mightContain(String key) {
        if (!properties.isBloomFilterEnabled()) {
            return true; // 不启用时允许通过
        }
        
        try {
            boolean result = localBloomFilter.mightContain(key);
            // 统计监控
            if (!result) {
                log.debug("布隆过滤器拦截: key={} 不存在", key);
            }
            return result;
        } catch (Exception e) {
            log.error("布隆过滤器查询失败", e);
            return true; // 出错时允许通过
        }
    }
    
    public void put(String key) {
        if (properties.isBloomFilterEnabled()) {
            localBloomFilter.put(key);
        }
    }
}

关键点：

• 布隆过滤器只存储Key的存在性信息
• 有极小的误判率（可配置）
• 不存在的Key能被准确识别并拦截

2. 空值缓存机制

@Component
public class NullValueHandler {
    
    private static final String NULL_VALUE = "NULL_CACHE";
    
    public void handleNullValue(String key) {
        try {
            // 本地缓存存储空值
            localCacheManager.put(key, NULL_VALUE);
            
            // Redis缓存存储空值（带较短过期时间）
            redisTemplate.opsForValue().set(key, NULL_VALUE, 
                    properties.getNullValueTtl(), TimeUnit.SECONDS);
                    
        } catch (Exception e) {
            log.error("设置空值缓存失败", e);
        }
    }
    
    public Object getValueFromCache(String key) {
        // 先查本地缓存
        Object localValue = localCacheManager.get(key);
        if (localValue != null) {
            return NULL_VALUE.equals(localValue) ? null : localValue;
        }
        
        // 再查Redis缓存
        String redisValue = redisTemplate.opsForValue().get(key);
        if (redisValue != null) {
            return NULL_VALUE.equals(redisValue) ? null : redisValue;
        }
        
        return null;
    }
}

设计要点：

• 空值也进行缓存，避免重复查询
• 空值缓存设置较短的过期时间
• 多级缓存都要存储空值状态

3. TTL随机化防雪崩

private long randomizeTtl(long baseTtl) {
    if (baseTtl <= 0) {
        return baseTtl;
    }
    
    // 在基础TTL基础上增加随机时间
    long randomRange = properties.getTtlRandomRange();
    long randomAddition = (long) (Math.random() * randomRange);
    
    return baseTtl + randomAddition;
}

原理：

• 避免大量Key在同一时间点过期
• 通过随机化分散缓存失效时间
• 有效防止缓存雪崩

4. 缓存预热机制

@Service
public class CachePreloaderService {
    
    @PostConstruct
    public void init() {
        if (properties.getPreheat().isStartup()) {
            preloadHotData();
        }
    }
    
    @Scheduled(fixedRateString = "${cache.protection.preheat.interval:3600000}")
    public void scheduledPreheat() {
        if (properties.getPreheat().isEnabled()) {
            preloadHotData();
        }
    }
    
    public void preloadHotData() {
        try {
            // 预热用户数据
            List<String> userIds = userService.getHotUserIds();
            userIds.forEach(userId -> {
                userService.getUserById(userId); // 触发缓存
            });
            
            // 预热商品数据
            List<String> productIds = productService.getHotProductIds();
            productIds.forEach(productId -> {
                productService.getProductById(productId);
            });
            
            log.info("缓存预热完成，预热数据量: {}", userIds.size() + productIds.size());
            
        } catch (Exception e) {
            log.error("缓存预热失败", e);
        }
    }
}

预热策略：

• 启动时预热核心数据
• 定时刷新热点数据
• 基于业务特点动态调整预热内容

AOP切面实现

通过AOP切面实现声明式的缓存防护：

@Aspect
@Component
public class CacheProtectionAspect {
    
    @Around("@annotation(com.example.cache.annotation.CacheableWithProtection)")
    public Object cacheableWithProtection(ProceedingJoinPoint joinPoint) throws Throwable {
        if (!properties.isEnabled()) {
            return joinPoint.proceed();
        }
        
        String cacheKey = generateCacheKey(joinPoint);
        
        try {
            // 第一层防护：布隆过滤器
            if (properties.isBloomFilterEnabled()) {
                if (!bloomFilterService.mightContain(cacheKey)) {
                    log.debug("布隆过滤器拦截，Key不存在: {}", cacheKey);
                    return null;
                }
            }
            
            // 第二层防护：检查缓存（包括空值处理）
            Object cachedValue = nullValueHandler.getValueFromCache(cacheKey);
            if (cachedValue != null) {
                log.debug("缓存命中: key={}", cacheKey);
                return cachedValue;
            }
            
            // 第三层防护：缓存击穿防护（加锁）
            return handleCacheBreakdown(joinPoint, cacheKey);
            
        } catch (Exception e) {
            log.error("缓存防护处理失败", e);
            return joinPoint.proceed(); // 降级到直接执行
        }
    }
    
    private Object handleCacheBreakdown(ProceedingJoinPoint joinPoint, String cacheKey) throws Throwable {
        String lockKey = "lock:" + cacheKey;
        RLock lock = redissonClient.getLock(lockKey);
        
        try {
            if (lock.tryLock(3, 10, TimeUnit.SECONDS)) {
                try {
                    // 双重检查
                    Object cachedValue = nullValueHandler.getValueFromCache(cacheKey);
                    if (cachedValue != null) {
                        return cachedValue;
                    }
                    
                    // 执行原方法
                    Object result = joinPoint.proceed();
                    
                    // 缓存结果
                    if (result != null) {
                        long ttl = randomizeTtl(getAnnotationTtl(joinPoint));
                        localCacheManager.put(cacheKey, result, ttl);
                        redisTemplate.opsForValue().set(cacheKey, result, ttl, TimeUnit.SECONDS);
                        bloomFilterService.put(cacheKey);
                    } else {
                        // 空值处理
                        nullValueHandler.handleNullValue(cacheKey);
                    }
                    
                    return result;
                } finally {
                    lock.unlock();
                }
            } else {
                // 获取锁失败，短暂等待后重试
                Thread.sleep(50);
                return handleCacheBreakdown(joinPoint, cacheKey);
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException("获取缓存锁被中断", e);
        }
    }
}

使用示例

1. 基本使用

@Service
public class UserService {
    
    @CacheableWithProtection(key = "user:#userId", ttl = 1800)
    public User getUserById(String userId) {
        // 数据库查询逻辑
        return userRepository.findById(userId);
    }
}

2. API测试

# 首次查询（较慢，建立缓存）
curl http://localhost:8080/api/cache/user/1001

# 第二次查询（快速命中缓存）
curl http://localhost:8080/api/cache/user/1001

# 查询不存在的数据（空值缓存防护）
curl http://localhost:8080/api/cache/user/999

# 查看缓存统计
curl http://localhost:8080/api/cache/stats

3. 配置文件

cache:
  protection:
    # 启用缓存防护
    enabled: true
    # 空值缓存过期时间（秒）
    null-value-ttl: 300
    # TTL随机化范围（秒）
    ttl-random-range: 300
    # 缓存预热配置
    preheat:
      enabled: true
      startup: true
      interval: 3600
    # 布隆过滤器配置
    bloom-filter:
      enabled: true
      expected-insertions: 1000000
      false-positive-probability: 0.01
    # 监控配置
    monitor:
      enabled: true
      sampling-rate: 0.1

性能优化建议

1. 缓存策略调优

# 调整本地缓存大小
spring:
  cache:
    caffeine:
      spec: maximumSize=10000,expireAfterWrite=30m

2. 布隆过滤器优化

cache:
  protection:
    bloom-filter:
      # 根据实际数据量调整
      expected-insertions: 5000000
      # 根据精度要求调整
      false-positive-probability: 0.001

3. 智能预热策略

// 基于访问统计的智能预热
@Scheduled(cron = "0 0 2 * * ?") // 每天凌晨2点
public void intelligentPreheat() {
    List<String> hotKeys = analyticsService.getHotKeys();
    cachePreloaderService.manualPreheat(hotKeys);
}

监控和告警

1. 关键指标监控

@Component
public class CacheMonitor {
    
    @Scheduled(fixedRate = 60000)
    public void reportCacheMetrics() {
        // 本地缓存命中率
        CacheStats stats = localCacheManager.getStats();
        monitoringService.sendMetrics("cache.local.hit_rate", stats.getHitRate());
        
        // 布隆过滤器误判率
        double actualFpp = bloomFilterService.getActualFpp();
        monitoringService.sendMetrics("cache.bloom.actual_fpp", actualFpp);
        
        // 缓存预热效果
        monitoringService.sendMetrics("cache.preheat.hot_keys", 
            cachePreloaderService.getHotKeysCount());
    }
}

2. 告警规则设置

# 告警阈值配置
alerts:
  cache:
    # 本地缓存命中率过低告警
    local-hit-rate-threshold: 80
    # 布隆过滤器误判率过高告警
    bloom-fpp-threshold: 0.02
    # 缓存穿透次数异常告警
    penetration-threshold: 1000

生产环境部署建议

1. 配置优化

# 生产环境配置
cache:
  protection:
    enabled: true
    # 生产环境可以适当延长空值缓存时间
    null-value-ttl: 600
    ttl-random-range: 600
    monitor:
      # 降低采样率减少性能影响
      sampling-rate: 0.01

2. 容量规划

• 根据业务量预估缓存容量需求
• 布隆过滤器大小需要提前规划
• 本地缓存和Redis内存合理分配

3. 故障处理

// 降级策略
public class CacheFallbackHandler {
    
    public Object fallback(ProceedingJoinPoint joinPoint) {
        try {
            // 直接执行原方法，跳过缓存
            return joinPoint.proceed();
        } catch (Throwable e) {
            throw new RuntimeException("缓存降级执行失败", e);
        }
    }
}

总结

这套缓存防护方案通过以下三个核心机制有效解决了热点Key问题：

1. 布隆过滤器：快速拦截不存在的Key，防止缓存穿透
2. 空值缓存：缓存null值，避免重复查询数据库
3. TTL随机化：分散缓存过期时间，防止缓存雪崩

配合缓存预热和多级缓存架构，能够显著提升系统的稳定性和性能。在实际应用中，建议根据具体业务场景调整相关参数，持续监控关键指标，确保防护效果。

记住，缓存防护不是一劳永逸的，需要根据业务发展和访问模式的变化持续优化。希望这套方案能帮助你的系统在高并发场景下更加稳定可靠！