高频接口的痛点

在我们的日常开发工作中，经常会遇到这样的场景：

• 用户头像、商品信息等数据被频繁访问
• 同一个接口在短时间内被大量重复调用
• 数据库压力过大，响应时间越来越长
• 服务器CPU和内存使用率居高不下

特别是对于一些热点数据，如果没有合理的缓存策略，很容易成为系统瓶颈。今天我们就来聊聊如何用Spring Cloud Gateway + 本地缓存 + Redis构建一个高效的多级缓存体系。

解决方案思路

今天我们要解决的，就是如何通过多级缓存架构大幅提升高频接口的响应速度。

核心思路是：

1. 多级缓存：结合本地缓存和Redis，实现就近访问
2. 缓存穿透防护：防止恶意请求击穿缓存
3. 缓存更新策略：确保数据一致性
4. 性能监控：实时监控缓存命中率

多级缓存架构设计

1. 本地缓存：Caffeine

本地缓存是最接近应用的缓存层级，访问速度最快。我们选用Caffeine作为本地缓存组件：

@Configuration
public class CacheConfig {
    
    @Bean
    public Cache<String, Object> localCache() {
        return Caffeine.newBuilder()
                .maximumSize(1000)
                .expireAfterWrite(Duration.ofMinutes(5))
                .recordStats()
                .build();
    }
}

Caffeine的优势在于：

• 高性能，接近JVM内访问速度
• 支持LRU、LFU等淘汰算法
• 提供丰富的统计信息

2. 分布式缓存：Redis

Redis作为分布式缓存，解决多实例部署下的数据共享问题：

spring:
  redis:
    host: localhost
    port: 6379
    timeout: 2000ms
    lettuce:
      pool:
        max-active: 20
        max-idle: 10
        min-idle: 5

3. 网关缓存过滤器

在Spring Cloud Gateway中实现缓存过滤器：

@Component
public class CacheGatewayFilterFactory extends AbstractGatewayFilterFactory<CacheConfig> {
    
    @Autowired
    private Cache<String, Object> localCache;
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Override
    public GatewayFilter apply(CacheConfig config) {
        return (exchange, chain) -> {
            ServerHttpRequest request = exchange.getRequest();
            String cacheKey = generateCacheKey(request);
            
            // 先查本地缓存
            Object cachedData = localCache.getIfPresent(cacheKey);
            if (cachedData != null) {
                return handleCachedResponse(exchange, cachedData);
            }
            
            // 再查Redis缓存
            cachedData = redisTemplate.opsForValue().get(cacheKey);
            if (cachedData != null) {
                localCache.put(cacheKey, cachedData);
                return handleCachedResponse(exchange, cachedData);
            }
            
            // 缓存未命中，继续向下执行
            return chain.filter(exchange).then(Mono.fromRunnable(() -> {
                // 后置处理：将响应结果存入缓存
                storeResponseInCache(exchange, cacheKey);
            }));
        };
    }
}

4. 缓存穿透防护

为了防止恶意请求或不存在的数据击穿缓存，我们采用布隆过滤器：

@Component
public class BloomFilterCacheHandler {
    
    private final BloomFilter<String> bloomFilter;
    
    public BloomFilterCacheHandler() {
        // 预估数据量和误判率
        this.bloomFilter = BloomFilter.create(
            Funnels.stringFunnel(Charset.defaultCharset()),
            1000000,  // 预期数据量
            0.01      // 误判率
        );
    }
    
    public boolean mightExist(String key) {
        return bloomFilter.mightContain(key);
    }
    
    public void put(String key) {
        bloomFilter.put(key);
    }
}

5. 缓存更新策略

对于缓存更新，我们采用"双写失效"策略：

@Service
public class CacheUpdateService {
    
    public void updateCache(String key, Object data) {
        // 更新Redis
        redisTemplate.opsForValue().set(key, data, Duration.ofMinutes(10));
        
        // 通知其他实例清除本地缓存
        notifyLocalCacheEviction(key);
    }
    
    private void notifyLocalCacheEviction(String key) {
        // 可以通过Redis Pub/Sub或消息队列通知
        redisTemplate.convertAndSend("cache-evict-channel", key);
    }
}

性能优化细节

1. 缓存键设计

合理的缓存键设计对性能至关重要：

private String generateCacheKey(ServerHttpRequest request) {
    String path = request.getPath().toString();
    MultiValueMap<String, String> params = request.getQueryParams();
    
    // 包含路径和参数，确保缓存的准确性
    String queryString = params.entrySet().stream()
        .map(entry -> entry.getKey() + "=" + entry.getValue())
        .collect(Collectors.joining("&"));
    
    return DigestUtils.md5DigestAsHex(
        (path + "?" + queryString).getBytes()
    );
}

2. 响应压缩

对于大体积的JSON响应，开启GZIP压缩：

spring:
  cloud:
    gateway:
      httpclient:
        response-timeout: 10s
        pool:
          max-connections: 500
      compression:
        enabled: true
        mime-types: text/html,text/xml,text/plain,application/json,application/xml
        min-response-size: 2048

3. 缓存预热

在系统启动时预热热点数据：

@Component
public class CacheWarmUpRunner implements CommandLineRunner {
    
    @Autowired
    private Cache<String, Object> localCache;
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Override
    public void run(String... args) throws Exception {
        // 预加载热点数据
        List<String> hotKeys = getHotKeys();
        for (String key : hotKeys) {
            Object data = redisTemplate.opsForValue().get(key);
            if (data != null) {
                localCache.put(key, data);
            }
        }
    }
}

监控与运维

1. 缓存命中率监控

@Component
public class CacheMetricsCollector {
    
    private final MeterRegistry meterRegistry;
    
    private final Counter hitCounter;
    private final Counter missCounter;
    
    public CacheMetricsCollector(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
        this.hitCounter = Counter.builder("cache.hits")
            .register(meterRegistry);
        this.missCounter = Counter.builder("cache.misses")
            .register(meterRegistry);
    }
    
    public void recordHit() {
        hitCounter.increment();
    }
    
    public void recordMiss() {
        missCounter.increment();
    }
}

2. 缓存配置动态调整

通过配置中心实现缓存策略的动态调整：

@RefreshScope
@Component
public class DynamicCacheConfig {
    
    @Value("${cache.ttl.local:300}")
    private int localCacheTtl;
    
    @Value("${cache.ttl.redis:600}")
    private int redisCacheTtl;
    
    @Value("${cache.size.local:1000}")
    private int localCacheSize;
}

实际效果

通过这套多级缓存架构，我们通常可以看到：

• 响应时间：从原来的200ms降低到20ms以内
• 吞吐量：QPS提升5-10倍
• 数据库压力：减少80%以上的无效查询
• 用户体验：页面加载速度显著提升

注意事项

在实施缓存策略时，需要注意以下几点：

1. 数据一致性：确保缓存与数据库的数据一致性
2. 内存使用：合理设置缓存大小，避免内存溢出
3. 缓存雪崩：设置随机过期时间，避免缓存同时失效
4. 安全考虑：敏感数据不应缓存，或需加密存储

总结

通过Spring Cloud Gateway + 本地缓存 + Redis的多级缓存架构，我们可以有效提升高频接口的性能，显著减轻后端服务的压力。这种架构不仅适用于商品信息查询，同样适用于用户信息、配置信息等各种热点数据的缓存场景。

希望这篇文章对你有所帮助！如果你觉得有用，欢迎关注【服务端技术精选】公众号，获取更多后端技术干货。

原文首发于 www.jiangyi.space

转载请注明出处