Spring Boot 缓存优化：从入门到精通-深圳市維司達科技有限公司

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(); List<Cache> 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 List<Product> 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 BloomFilter<Long> 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 Map<String, CacheStats> getCacheStats() { Map<String, 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.Cache<Object, Object> nativeCache = caffeineCache.getNativeCache(); CacheStats cacheStats = nativeCache.stats(); stats.put(cacheName, cacheStats); } }); return stats; } public void printStats() { Map<String, 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 ResponseEntity<Map<String, Object>> getCacheStats() { Map<String, Object> result = new HashMap<>(); Map<String, CacheStats> stats = cacheMetricsService.getCacheStats(); stats.forEach((cacheName, cacheStats) -> { Map<String, 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 ResponseEntity<Void> clearAllCache() { cacheMetricsService.getCacheStats().keySet().forEach(cacheName -> { Cache cache = cacheMetricsService.cacheManager.getCache(cacheName); if (cache != null) { cache.clear(); } }); return ResponseEntity.noContent().build(); } }