在现代应用开发中，缓存是提升系统性能的关键技术。Spring框架通过@Cache系列注解提供了声明式缓存抽象，大大简化了缓存集成。本文将全面解析这些注解的使用方法、核心机制和最佳实践。
目录
一、@Cache注解家族概览
二、核心注解详解与使用
2.1 @Cacheable - 结果缓存
2.2 @CachePut - 更新缓存
2.3 @CacheEvict - 清除缓存
2.4 @Caching - 组合操作
2.5 @CacheConfig - 类级配置
三、集成配置（Spring Boot）
3.1 添加依赖
3.2 启用缓存
3.3 缓存配置
四、高级特性与定制
4.1 自定义Key生成器
4.2 条件缓存进阶
4.3 多级缓存策略
五、生产环境最佳实践
5.1 缓存穿透防护
5.2 缓存雪崩预防
5.3 缓存一致性策略
六、性能优化指南
6.1 缓存粒度控制
6.2 批量操作优化
6.3 监控与指标
七、常见问题与解决方案
7.1 缓存不生效排查
7.2 缓存一致性挑战
7.3 序列化异常
八、缓存注解的局限性
8.1 不适合场景
8.2 替代方案
总结：缓存使用黄金法则
一、@Cache注解家族概览
Spring提供了五个核心缓存注解，共同构建了声明式缓存体系：
注解作用使用场景@Cacheable方法结果缓存查询类方法（读多写少）@CachePut更新缓存内容更新操作后刷新缓存@CacheEvict清除缓存条目数据变更后失效缓存@Caching组合多个缓存操作需要同时进行多种缓存操作@CacheConfig类级别共享缓存配置统一管理类的缓存配置
二、核心注解详解与使用
2.1 @Cacheable - 结果缓存
核心功能：将方法返回值缓存，后续相同参数的调用直接返回缓存值
@Service
public class ProductService {
@Cacheable(value = "products", key = "#id")
public Product getProductById(Long id) {
// 模拟数据库查询
return productRepository.findById(id).orElse(null);
}
@Cacheable(
value = "products",
key = "#category + ':' + #pageable.pageNumber",
condition = "#pageable.pageSize <= 50",
unless = "#result == null"
)
public Page
String category,
Pageable pageable
) {
// 分页查询
return productRepository.findByCategory(category, pageable);
}
}
关键参数解析：
value/cacheNames：指定缓存名称（必填）
key：自定义缓存键（SpEL表达式）
condition：缓存条件（满足条件才缓存）
unless：否决缓存（满足条件不缓存）
keyGenerator：自定义键生成器（替代key属性）
cacheManager：指定缓存管理器
2.2 @CachePut - 更新缓存
核心功能：总是执行方法，并使用返回值更新缓存
@CachePut(value = "products", key = "#product.id")
public Product updateProduct(Product product) {
return productRepository.save(product);
}
使用场景：
数据更新后需要立即刷新缓存
避免后续查询穿透到数据库
注意事项：
方法必须有返回值
需确保key与@Cacheable使用的key一致
2.3 @CacheEvict - 清除缓存
核心功能：删除指定缓存条目
@CacheEvict(value = "products", key = "#id")
public void deleteProduct(Long id) {
productRepository.deleteById(id);
}
// 清空整个缓存
@CacheEvict(value = "products", allEntries = true)
public void clearProductCache() {}
关键参数：
allEntries：是否清空整个缓存区域
beforeInvocation：是否在方法执行前清除（默认false）
true：无论方法是否成功都清除
false：方法成功后清除（推荐）
2.4 @Caching - 组合操作
核心功能：组合多个缓存操作
@Caching(
evict = {
@CacheEvict(value = "products", key = "#product.id"),
@CacheEvict(value = "categoryProducts", allEntries = true)
},
put = {
@CachePut(value = "productDetails", key = "#product.id")
}
)
public Product updateProductDetails(Product product) {
// 更新逻辑
return productRepository.save(product);
}
2.5 @CacheConfig - 类级配置
核心功能：类级别共享缓存配置
@Service
@CacheConfig(cacheNames = "products")
public class ProductService {
@Cacheable(key = "#id")
public Product getById(Long id) {
// 无需重复指定cacheNames
}
@CacheEvict(key = "#id")
public void delete(Long id) {
// ...
}
}
三、集成配置（Spring Boot）
3.1 添加依赖
3.2 启用缓存
@SpringBootApplication
@EnableCaching // 关键注解
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
3.3 缓存配置
# application.yml
spring:
cache:
type: caffeine
caffeine:
spec: maximumSize=10000,expireAfterWrite=10m
cache-names: products, users, orders
四、高级特性与定制
4.1 自定义Key生成器
@Configuration
public class CacheConfig {
@Bean("customKeyGenerator")
public KeyGenerator keyGenerator() {
return (target, method, params) -> {
StringBuilder key = new StringBuilder();
key.append(target.getClass().getSimpleName());
key.append(":");
key.append(method.getName());
for (Object param : params) {
if (param != null) {
key.append(":");
if (param instanceof Pageable pageable) {
key.append(pageable.getPageNumber());
} else {
key.append(param.toString());
}
}
}
return key.toString();
};
}
}
// 使用
@Cacheable(value="products", keyGenerator="customKeyGenerator")
public Page
// ...
}
4.2 条件缓存进阶
// 仅缓存价格大于100的产品
@Cacheable(
value = "products",
condition = "#result != null && #result.price > 100"
)
// 不缓存缺货产品
@Cacheable(
value = "products",
unless = "#result.stock == 0"
)
// 仅管理员查询不缓存
@Cacheable(
value = "products",
condition = "!T(com.example.SecurityUtils).isAdmin()"
)
4.3 多级缓存策略
@Caching(
cacheable = {
@Cacheable(value = "localCache", key = "#id"),
@Cacheable(value = "redisCache", key = "#id")
}
)
public Product getProductWithMultiCache(Long id) {
// ...
}
五、生产环境最佳实践
5.1 缓存穿透防护
// 方案1：缓存空值
@Cacheable(value = "users", unless = "#result == null")
public User getUserById(Long id) {
// 返回null也会缓存
}
// 方案2：使用Optional
@Cacheable(value = "users")
public Optional
// 明确区分存在/不存在
}
5.2 缓存雪崩预防
// 差异化过期时间
spring.cache.caffeine.spec=maximumSize=10000,expireAfterWrite=${random.int(5,15)}m
// 添加Jitter
@Cacheable(value = "products", key = "#id")
@CacheExpire(time = 10, timeUnit = TimeUnit.MINUTES, jitter = 2)
public Product getProduct(Long id) {
// ...
}
5.3 缓存一致性策略
策略实现方式适用场景先更DB后删缓存@CacheEvict通用场景双删策略更新前后各删除一次高并发场景延迟双删更新后异步延迟删除极端高并发基于消息队列通过消息通知各节点失效缓存分布式系统
双删策略实现：
@Transactional
public void updateProduct(Product product) {
// 1. 首次删除
cacheManager.getCache("products").evict(product.getId());
// 2. 更新数据库
productRepository.save(product);
// 3. 二次删除（事务提交后）
TransactionSynchronizationManager.registerSynchronization(
new TransactionSynchronization() {
@Override
public void afterCommit() {
cacheManager.getCache("products").evict(product.getId());
}
}
);
}
六、性能优化指南
6.1 缓存粒度控制
细粒度缓存：对象属性级缓存（节省内存）
@Cacheable(value = "productNames", key = "#id")
public String getProductName(Long id) {
return productRepository.findNameById(id);
} 粗粒度缓存：完整对象缓存（减少查询次数）
6.2 批量操作优化
@Cacheable(value = "products")
public Map
// 批量查询数据库
List
return products.stream()
.collect(Collectors.toMap(Product::getId, Function.identity()));
}
// 调用方
public void processOrder(List
Map
// 使用productMap处理
}
6.3 监控与指标
// 暴露缓存指标
management:
endpoints:
web:
exposure:
include: health,info,caches,metrics
// 自定义监控
@Bean
public MeterRegistryCustomizer
return registry -> {
CaffeineCache cache = (CaffeineCache) cacheManager.getCache("products");
cache.getNativeCache().stats().hitCount();
cache.getNativeCache().stats().missCount();
};
}
七、常见问题与解决方案
7.1 缓存不生效排查
检查点：
是否添加@EnableCaching
方法是否为public
是否在同一个类内调用（AOP代理问题）
条件表达式是否错误
解决方案：
// 避免自调用问题
@Autowired
private ProductService selfProxy; // 注入自身代理
public void internalCall(Long id) {
// 错误：直接调用导致缓存失效
// getProductById(id);
// 正确：通过代理调用
selfProxy.getProductById(id);
}
7.2 缓存一致性挑战
问题场景：集群环境下节点间缓存不一致
解决方案：
// 方案1：使用集中式缓存（Redis）
spring.cache.type=redis
// 方案2：缓存变更通知
@CacheEvict(value = "products", key = "#product.id")
public Product update(Product product) {
// 更新数据库
// 发送缓存失效事件
applicationEventPublisher.publishEvent(
new CacheEvictEvent("products", product.getId()));
}
// 其他节点监听事件
@EventListener
public void handleCacheEvict(CacheEvictEvent event) {
cacheManager.getCache(event.getCacheName()).evict(event.getKey());
}
7.3 序列化异常
典型错误：java.io.NotSerializableException
解决方案：
实现Serializable接口
public class Product implements Serializable {
// ...
} 使用JSON序列化（推荐）
@Bean
public RedisCacheConfiguration cacheConfiguration() {
return RedisCacheConfiguration.defaultCacheConfig()
.serializeValuesWith(SerializationPair.fromSerializer(
new Jackson2JsonRedisSerializer<>(Object.class)
);
}
八、缓存注解的局限性
8.1 不适合场景
高频更新数据：缓存频繁失效导致性能下降
严格一致性要求：金融交易等场景
超大对象缓存：可能引起GC压力
8.2 替代方案
场景替代方案高频更新直接读数据库严格一致性分布式事务+数据库海量数据外部缓存服务（Redis集群）
总结：缓存使用黄金法则
缓存选择：
本地缓存：高性能、单机场景（Caffeine）
分布式缓存：集群环境（Redis）
键设计原则：
唯一性：不同参数产生不同键
可读性：包含业务含义
简洁性：避免过长键值
失效策略：
TTL+随机抖动：防雪崩
主动失效：数据变更时立即失效
监控指标：
命中率：>80%为健康
加载时间：<50ms
内存使用：<70%最大限制
重要提醒：缓存不是万能的，不合理的使用反而会降低系统性能。始终基于性能测试和监控数据做决策。