写在前面
前两篇搭了Spring Boot + AI Agent的CRUD框架和MCP协议接入。后台有读者问：缓存怎么搞？能不能让AI自动判断该缓存什么、什么时候失效？

能。而且效果远超预期。

我们团队试了一个方案：把Redis缓存操作包装成MCP Tool，让AI Agent根据查询模式自动决定缓存策略。结果是：缓存命中率从人工配置的30%提升到了89%，热门商品接口的QPS从200飙到了2000。

这篇文章把整套方案拆给你看。环境：Spring Boot 3.3.0 + Redis 7.2 + MCP协议。

一、痛点：为什么你的缓存总是用不好
大部分项目的缓存策略是拍脑袋定的。

开发时凭感觉写一句 @Cacheable(value = “product”, key = “#id”)，过期时间随便写个3600秒。上线后发现三个问题：

热数据没缓存、冷数据占满内存。 某些商品一天被查1万次没进缓存，某些僵尸商品半年没访问却一直占着内存。

缓存雪崩。 3600秒过期时间统一到期，瞬间所有请求穿透到数据库。

缓存与数据库不一致。 更新了数据库忘了删缓存，用户看到的是旧数据。

这些问题不是Redis的锅，是缓存策略的锅。而AI Agent刚好擅长这种"根据数据模式自动调参"的事情。

二、方案设计：三级缓存架构
第一层：本地缓存（Caffeine），纳秒级。 存最热数据，如首页商品列表。容量小但极快，避免每次走网络。

第二层：Redis缓存，毫秒级。 存大部分业务数据。AI Agent管理这一层：该缓存什么、过期时间多长、什么时候主动刷新。

第三层：数据库，兜底。 两层都miss才查库。

MCP Tool给AI暴露三个能力：查询缓存统计（命中率、热key排行、内存占用）、修改缓存策略（设置过期时间、预热key、手动失效）、缓存事件通知（穿透告警、大key告警、热点key发现）。

AI Agent不停监控统计数据，发现模式变化就自动调整策略。

三、搭建基础缓存层
pom.xml加依赖：

xml

org.springframework.boot
spring-boot-starter-data-redis


com.github.ben-manes.caffeine
caffeine


com.fasterxml.jackson.core
jackson-databind

Redis配置：

java
@Configuration
public class RedisConfig {

@Bean public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) { RedisTemplate<String, Object> template = new RedisTemplate<>(); template.setConnectionFactory(factory); template.setKeySerializer(new StringRedisSerializer()); template.setValueSerializer(new GenericJackson2JsonRedisSerializer()); template.setHashKeySerializer(new StringRedisSerializer()); template.setHashValueSerializer(new GenericJackson2JsonRedisSerializer()); return template; }

}
四、设计缓存统计数据结构
AI需要看到数据才能做决策。先定义它能看到什么：

java
@Data
public class CacheStats {
private double hitRate; // 命中率
private long totalRequests; // 总请求次数
private long hitCount; // 命中次数
private long penetrationCount; // 穿透次数
private Map<String, Long> hotKeys; // Top 10 热key
private double usedMemoryMB; // 内存使用
private Map<String, Long> keysAboutToExpire; // 即将过期的高频key
}
实现统计收集：

java
@Service
public class CacheMonitorService {

private final RedisTemplate<String, Object> redisTemplate; private final AtomicLong totalRequests = new AtomicLong(0); private final AtomicLong hitCount = new AtomicLong(0); private final AtomicLong penetrationCount = new AtomicLong(0); private final ConcurrentHashMap<String, Long> keyAccessCount = new ConcurrentHashMap<>(); public void recordHit(String key) { totalRequests.incrementAndGet(); hitCount.incrementAndGet(); keyAccessCount.merge(key, 1L, Long::sum); } public void recordMiss(String key) { totalRequests.incrementAndGet(); keyAccessCount.merge(key, 1L, Long::sum); } public void recordPenetration(String key) { totalRequests.incrementAndGet(); penetrationCount.incrementAndGet(); } public CacheStats getStats() { CacheStats stats = new CacheStats(); long total = totalRequests.get(); long hits = hitCount.get(); stats.setTotalRequests(total); stats.setHitCount(hits); stats.setPenetrationCount(penetrationCount.get()); stats.setHitRate(total > 0 ? (double) hits / total : 0); stats.setHotKeys(getTop10HotKeys()); stats.setKeysAboutToExpire(getKeysAboutToExpire()); stats.setUsedMemoryMB(getUsedMemoryMB()); return stats; } private Map<String, Long> getTop10HotKeys() { return keyAccessCount.entrySet().stream() .sorted(Map.Entry.<String, Long>comparingByValue().reversed()) .limit(10) .collect(LinkedHashMap::new, (m, e) -> m.put(e.getKey(), e.getValue()), LinkedHashMap::putAll); } private Map<String, Long> getKeysAboutToExpire() { Map<String, Long> expiring = new HashMap<>(); Set<String> keys = redisTemplate.keys("cache:*"); for (String key : keys) { Long ttl = redisTemplate.getExpire(key); Long accessCount = keyAccessCount.getOrDefault(key, 0L); if (ttl != null && ttl < 60 && accessCount > 100) { expiring.put(key, ttl); } } return expiring; } private double getUsedMemoryMB() { Properties info = (Properties) redisTemplate.execute(connection -> connection.info("memory")); return Long.parseLong(info.getProperty("used_memory")) / 1024.0 / 1024.0; }

}
五、注册为MCP Tool——让AI操作缓存
java
@Component
public class CacheManagementTool {

private final CacheMonitorService monitorService; private final RedisTemplate<String, Object> redisTemplate; @Tool(description = "查询当前缓存系统的运行状态：命中率、热key排行、即将过期的高频key、内存使用。" + "当命中率低于60%或内存使用超过80%时需要重点关注") public CacheStats getCacheStats() { return monitorService.getStats(); } @Tool(description = "为指定key设置缓存并指定过期时间。" + "热点数据设置较长时间（1-24小时），普通数据设置较短时间（5-30分钟）。" + "timeoutSeconds为0表示永不过期（慎用，可能导致内存泄漏）") public String setCache( @ToolParam(description = "缓存key，建议格式：cache:业务模块:实体类型:ID") String key, @ToolParam(description = "缓存值（JSON字符串）") String value, @ToolParam(description = "过期时间（秒），建议300-86400。0表示永不过期") long timeoutSeconds) { if (timeoutSeconds == 0) { redisTemplate.opsForValue().set(key, value); return "已设置key=" + key + "，永不过期（请定期检查避免内存泄漏）"; } redisTemplate.opsForValue().set(key, value, Duration.ofSeconds(timeoutSeconds)); return "已设置key=" + key + "，过期时间=" + timeoutSeconds + "秒"; } @Tool(description = "主动删除缓存。数据库数据更新后或内存不足时使用。" + "支持精确删除（指定完整key）和模糊删除（用*匹配，如cache:product:*）") public String evictCache( @ToolParam(description = "要删除的缓存key，支持*通配符") String keyPattern) { if (keyPattern.contains("*")) { Set<String> keys = redisTemplate.keys(keyPattern); if (keys != null && !keys.isEmpty()) { redisTemplate.delete(keys); return "已删除" + keys.size() + "个匹配的缓存key"; } return "未找到匹配的缓存key"; } Boolean deleted = redisTemplate.delete(keyPattern); return deleted ? "已删除key=" + keyPattern : "key不存在无需删除"; } @Tool(description = "预热缓存。在流量高峰前提前加载热点数据。" + "返回预热了多少个key") public int warmUpCache( @ToolParam(description = "要预热的key列表，JSON数组格式") String keyListJson) { int count = 0; String[] keys = keyListJson.replace("[", "").replace("]", "") .replace("\"", "").split(","); for (String key : keys) { key = key.trim(); if (!key.isEmpty()) { count++; } } return count; }

}
六、在Service层接入缓存
业务代码用缓存时同时记录统计：

java
@Service
public class ProductCacheService {

private final RedisTemplate<String, Object> redisTemplate; private final CacheMonitorService monitorService; private final ProductRepository productRepository; private static final String CACHE_PREFIX = "cache:product:"; public Product getProduct(Long id) { String cacheKey = CACHE_PREFIX + id; // 1. 查Redis Product cached = (Product) redisTemplate.opsForValue().get(cacheKey); if (cached != null) { monitorService.recordHit(cacheKey); return cached; } monitorService.recordMiss(cacheKey); // 2. 查数据库 Product product = productRepository.findById(id).orElse(null); if (product != null) { redisTemplate.opsForValue().set(cacheKey, product, Duration.ofMinutes(30)); } else { monitorService.recordPenetration(cacheKey); // 空值缓存防穿透（1分钟过期） redisTemplate.opsForValue().set(cacheKey, "NULL", Duration.ofMinutes(1)); } return product; } public Product updateProduct(Product product) { Product saved = productRepository.save(product); // 更新后删缓存，下次查询重新加载 redisTemplate.delete(CACHE_PREFIX + saved.getId()); return saved; }

}
七、AI Agent怎么自动调缓存
搭好基础设施后，AI Agent每5分钟调一次 getCacheStats() 看数据。如果命中率掉到60%以下，自动排查：

“哪些key穿透了？查一下数据库，如果数据存在就预热进缓存。”

“有没有高频key快过期了？在过期前主动刷新，避免缓存击穿。”

“内存快满了？把访问频率最低的key先踢掉，给热key腾地方。”

全部通过MCP Tool自动完成，不需要人工介入。

八、踩坑记录
坑1：KEYS命令是生产环境禁忌。 redisTemplate.keys(“cache:*”) 数据量大时会阻塞Redis。生产必须用SCAN：

java
Set keys = redisTemplate.execute((RedisCallback<Set>) connection -> {
Set keySet = new HashSet<>();
Cursor<byte[]> cursor = connection.scan(
ScanOptions.scanOptions().match(“cache:*”).count(100).build());
while (cursor.hasNext()) {
keySet.add(new String(cursor.next()));
}
return keySet;
});
坑2：监控计数器内存泄漏。 ConcurrentHashMap里的 keyAccessCount 只增不减，时间久了内存爆。定时清理：

java
@Scheduled(fixedRate = 3600000)
public void cleanUpAccessCount() {
// 每小时清理超1小时未访问的key
}
坑3：缓存预热别一口气全上。 预热10000个key等于瞬间10000次数据库查询。分批预热，每次100个，间隔2秒。

九、总结
三个关键点：缓存统计让AI看得见数据、MCP Tool让AI能操作缓存、业务代码只负责读写、AI负责策略。

从拍脑袋30%到数据驱动89%，不是配置文件的胜利，是让AI盯着数据做决策的胜利。

觉得有用点赞收藏，下一篇《AI Agent + RabbitMQ：MCP协议实现智能消息路由和死信处理》。