Spring Boot 缓存优化从入门到精通核心概念缓存是提高应用性能的重要手段Spring Boot 提供了强大的缓存支持。通过合理配置和使用缓存可以显著减少数据库访问次数提高响应速度。Spring Boot 缓存抽象Spring Boot 提供了统一的缓存抽象层支持多种缓存实现ConcurrentHashMap默认缓存实现适合开发环境Redis分布式缓存适合生产环境Caffeine高性能本地缓存EhCache成熟的缓存解决方案缓存配置// 缓存配置类 Configuration EnableCaching public class CacheConfig { Bean public CacheManager cacheManager() { SimpleCacheManager cacheManager new SimpleCacheManager(); ListCache caches Arrays.asList( new ConcurrentMapCache(users), new ConcurrentMapCache(products), new ConcurrentMapCache(orders) ); cacheManager.setCaches(caches); return cacheManager; } } // 使用 Redis 作为缓存 Configuration EnableCaching public class RedisCacheConfig { Bean public CacheManager cacheManager(RedisConnectionFactory connectionFactory) { RedisCacheConfiguration config RedisCacheConfiguration.defaultCacheConfig() .entryTtl(Duration.ofMinutes(30)) .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer())) .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer())); return RedisCacheManager.builder(connectionFactory) .cacheDefaults(config) .build(); } } // 使用 Caffeine 作为缓存 Configuration EnableCaching public class CaffeineCacheConfig { Bean public CacheManager cacheManager() { CaffeineCacheManager cacheManager new CaffeineCacheManager(); cacheManager.setCaffeine(Caffeine.newBuilder() .initialCapacity(100) .maximumSize(500) .expireAfterWrite(Duration.ofMinutes(30)) .recordStats()); cacheManager.setCacheNames(Arrays.asList(users, products, orders)); return cacheManager; } }缓存注解使用// 缓存服务示例 Service public class UserService { private final UserRepository userRepository; public UserService(UserRepository userRepository) { this.userRepository userRepository; } Cacheable(value users, key #id) public User findById(Long id) { // 只有第一次调用时会执行此方法后续调用直接从缓存获取 return userRepository.findById(id).orElse(null); } Cacheable(value users, key #email) public User findByEmail(String email) { return userRepository.findByEmail(email).orElse(null); } CachePut(value users, key #user.id) public User save(User user) { // 更新缓存 return userRepository.save(user); } CacheEvict(value users, key #id) public void deleteById(Long id) { // 删除缓存 userRepository.deleteById(id); } CacheEvict(value users, allEntries true) public void clearCache() { // 清除所有用户缓存 } Caching( put { CachePut(value users, key #user.id), CachePut(value users, key #user.email) } ) public User update(User user) { // 更新多个缓存条目 return userRepository.save(user); } }缓存条件Service public class ProductService { private final ProductRepository productRepository; public ProductService(ProductRepository productRepository) { this.productRepository productRepository; } Cacheable(value products, key #id, condition #id 0) public Product findById(Long id) { // 只有 id 0 时才使用缓存 return productRepository.findById(id).orElse(null); } Cacheable(value products, key #name, unless #result null) public Product findByName(String name) { // 只有结果不为 null 时才缓存 return productRepository.findByName(name).orElse(null); } Cacheable(value products, key #category, condition #category ! ALL) public ListProduct findByCategory(String category) { // 只有 category 不是 ALL 时才使用缓存 return productRepository.findByCategory(category); } }缓存与事务Service Transactional public class OrderService { private final OrderRepository orderRepository; private final ProductService productService; public OrderService(OrderRepository orderRepository, ProductService productService) { this.orderRepository orderRepository; this.productService productService; } Cacheable(value orders, key #id) public Order findById(Long id) { return orderRepository.findById(id).orElse(null); } CachePut(value orders, key #order.id) public Order create(Order order) { // 在事务内创建订单缓存会在事务提交后更新 return orderRepository.save(order); } CacheEvict(value orders, key #id) public void cancel(Long id) { Order order findById(id); if (order ! null) { order.setStatus(CANCELLED); orderRepository.save(order); } } }缓存穿透解决方案// 缓存穿透查询不存在的数据 Service public class CachePenetrationService { private static final String NULL_VALUE NULL_VALUE; Autowired private UserRepository userRepository; Cacheable(value users, key #id) public User findById(Long id) { User user userRepository.findById(id).orElse(null); if (user null) { // 返回一个特殊的空值标记防止缓存穿透 throw new UserNotFoundException(User not found); } return user; } } // 使用布隆过滤器防止缓存穿透 Component public class BloomFilterCache { private final BloomFilterLong userBloomFilter; public BloomFilterCache() { // 预计插入 1000000 条数据误判率 0.01% this.userBloomFilter BloomFilter.create( Funnels.longFunnel(), 1000000, 0.0001 ); } public void add(Long id) { userBloomFilter.put(id); } public boolean mightContain(Long id) { return userBloomFilter.mightContain(id); } } Service public class UserServiceWithBloomFilter { private final BloomFilterCache bloomFilterCache; private final UserRepository userRepository; public UserServiceWithBloomFilter(BloomFilterCache bloomFilterCache, UserRepository userRepository) { this.bloomFilterCache bloomFilterCache; this.userRepository userRepository; } Cacheable(value users, key #id) public User findById(Long id) { // 先检查布隆过滤器 if (!bloomFilterCache.mightContain(id)) { throw new UserNotFoundException(User not found); } return userRepository.findById(id).orElseThrow(() - new UserNotFoundException(User not found)); } }缓存击穿解决方案// 缓存击穿热点数据过期时大量请求同时访问数据库 Service public class HotProductService { private final ProductRepository productRepository; private final ReentrantLock lock new ReentrantLock(); Cacheable(value products, key #id) public Product getHotProduct(Long id) { return getProductFromDb(id); } private Product getProductFromDb(Long id) { // 使用双重检查锁防止缓存击穿 String cacheKey products:: id; // 尝试获取锁 if (lock.tryLock()) { try { // 再次检查缓存 Product cached getFromCache(cacheKey); if (cached ! null) { return cached; } // 从数据库获取 Product product productRepository.findById(id).orElse(null); // 更新缓存 if (product ! null) { updateCache(cacheKey, product); } return product; } finally { lock.unlock(); } } else { // 等待其他线程更新缓存 try { Thread.sleep(100); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } // 再次尝试从缓存获取 return getHotProduct(id); } } private Product getFromCache(String key) { // 从缓存获取 return null; } private void updateCache(String key, Product product) { // 更新缓存 } }缓存雪崩解决方案// 缓存雪崩大量缓存同时过期 Configuration EnableCaching public class CacheAvalancheConfig { Bean public CacheManager cacheManager() { CaffeineCacheManager cacheManager new CaffeineCacheManager(); cacheManager.setCaffeine(Caffeine.newBuilder() .initialCapacity(100) .maximumSize(500) .expireAfterWrite(Duration.ofMinutes(30)) .expireAfterAccess(Duration.ofMinutes(10)) .recordStats()); return cacheManager; } } Service public class ProductServiceWithRandomExpire { private final ProductRepository productRepository; public ProductServiceWithRandomExpire(ProductRepository productRepository) { this.productRepository productRepository; } Cacheable(value products, key #id) public Product findById(Long id) { Product product productRepository.findById(id).orElse(null); if (product ! null) { // 设置随机过期时间避免缓存雪崩 int randomMinutes new Random().nextInt(10) 25; // 25-35 分钟 updateCacheWithExpire(products:: id, product, randomMinutes); } return product; } private void updateCacheWithExpire(String key, Product product, int minutes) { // 更新缓存并设置过期时间 } }缓存监控// 缓存监控服务 Service public class CacheMetricsService { private final CacheManager cacheManager; public CacheMetricsService(CacheManager cacheManager) { this.cacheManager cacheManager; } public MapString, CacheStats getCacheStats() { MapString, CacheStats stats new HashMap(); cacheManager.getCacheNames().forEach(cacheName - { Cache cache cacheManager.getCache(cacheName); if (cache instanceof CaffeineCache) { CaffeineCache caffeineCache (CaffeineCache) cache; com.github.benmanes.caffeine.cache.CacheObject, Object nativeCache caffeineCache.getNativeCache(); CacheStats cacheStats nativeCache.stats(); stats.put(cacheName, cacheStats); } }); return stats; } public void printStats() { MapString, CacheStats stats getCacheStats(); stats.forEach((cacheName, cacheStats) - { System.out.println(Cache: cacheName); System.out.println( Hits: cacheStats.hitCount()); System.out.println( Misses: cacheStats.missCount()); System.out.println( Hit Rate: String.format(%.2f%%, cacheStats.hitRate() * 100)); System.out.println( Evictions: cacheStats.evictionCount()); System.out.println(); }); } } // 缓存统计端点 RestController RequestMapping(/cache) public class CacheController { private final CacheMetricsService cacheMetricsService; public CacheController(CacheMetricsService cacheMetricsService) { this.cacheMetricsService cacheMetricsService; } GetMapping(/stats) public ResponseEntityMapString, Object getCacheStats() { MapString, Object result new HashMap(); MapString, CacheStats stats cacheMetricsService.getCacheStats(); stats.forEach((cacheName, cacheStats) - { MapString, Object cacheInfo new HashMap(); cacheInfo.put(hits, cacheStats.hitCount()); cacheInfo.put(misses, cacheStats.missCount()); cacheInfo.put(hitRate, String.format(%.2f%%, cacheStats.hitRate() * 100)); cacheInfo.put(evictions, cacheStats.evictionCount()); cacheInfo.put(averageLoadPenalty, cacheStats.averageLoadPenalty()); result.put(cacheName, cacheInfo); }); return ResponseEntity.ok(result); } DeleteMapping(/clear) public ResponseEntityVoid clearAllCache() { cacheMetricsService.getCacheStats().keySet().forEach(cacheName - { Cache cache cacheMetricsService.cacheManager.getCache(cacheName); if (cache ! null) { cache.clear(); } }); return ResponseEntity.noContent().build(); } }最佳实践选择合适的缓存策略根据业务场景选择本地缓存或分布式缓存设置合理的过期时间根据数据更新频率设置过期时间处理缓存与数据库一致性使用 CachePut 更新缓存防止缓存穿透使用布隆过滤器或空值缓存防止缓存击穿使用互斥锁或分布式锁防止缓存雪崩设置随机过期时间监控缓存性能定期检查缓存命中率合理规划缓存键使用有意义的缓存键命名规范实际应用场景高频查询场景如商品详情、用户信息热点数据缓存如首页推荐、热门商品会话缓存如用户登录状态计算结果缓存如复杂查询结果总结Spring Boot 的缓存抽象层提供了强大而灵活的缓存支持。通过合理配置和使用缓存可以显著提高应用性能。在实际应用中需要根据业务场景选择合适的缓存策略并注意处理缓存穿透、击穿和雪崩等问题。别叫我大神叫我 Alex 就好。这其实可以更优雅一点合理的缓存配置让应用性能变得更加出色和高效。