1. 緩存基礎概念

1.1 什么是緩存

緩存是一種高速存儲技術，用于臨時存儲頻繁訪問的數據，以提高系統性能和響應速度。在軟件架構中，緩存通常位于應用程序和數據庫之間，作為數據的快速訪問層。

1.2 緩存的作用

• 提高響應速度：從內存中讀取數據比從磁盤快幾個數量級
• 減少數據庫壓力：減少對數據庫的直接訪問
• 提升用戶體驗：快速響應用戶請求
• 節約成本：減少服務器資源消耗

1.3 常見的緩存類型

• 本地緩存：如HashMap、Guava Cache
• 分布式緩存：如Redis、Memcached
• 數據庫緩存：如MySQL查詢緩存
• CDN緩存：內容分發網絡緩存

1.4 緩存架構示例

// 典型的緩存使用模式
public class UserService {private RedisTemplate<String, Object> redisTemplate;private UserRepository userRepository;public User getUserById(Long userId) {String key = "user:" + userId;// 1. 先查緩存User user = (User) redisTemplate.opsForValue().get(key);if (user != null) {return user; // 緩存命中}// 2. 緩存未命中，查數據庫user = userRepository.findById(userId);if (user != null) {// 3. 將數據寫入緩存redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));}return user;}
}

2. 緩存雪崩 (Cache Avalanche)

2.1 什么是緩存雪崩

緩存雪崩是指在同一時間，大量的緩存key同時失效，導致大量請求直接打到數據庫上，造成數據庫瞬間壓力過大甚至宕機的現象。

2.2 緩存雪崩的原因

1. 緩存服務器宕機：Redis服務器突然宕機
2. 大量key同時過期：設置了相同的過期時間
3. 緩存預熱不充分：系統重啟后緩存為空

2.3 緩存雪崩的危害

• 數據庫瞬間壓力暴增
• 系統響應時間急劇增加
• 可能導致數據庫連接池耗盡
• 嚴重時可能導致整個系統崩潰

2.4 緩存雪崩的解決方案

方案1：設置隨機過期時間

@Service
public class ProductService {private RedisTemplate<String, Object> redisTemplate;private ProductRepository productRepository;public Product getProductById(Long productId) {String key = "product:" + productId;Product product = (Product) redisTemplate.opsForValue().get(key);if (product == null) {product = productRepository.findById(productId);if (product != null) {// 設置隨機過期時間：30分鐘 + 0-10分鐘的隨機時間int randomMinutes = new Random().nextInt(10);Duration expireTime = Duration.ofMinutes(30 + randomMinutes);redisTemplate.opsForValue().set(key, product, expireTime);}}return product;}
}

方案2：緩存集群和主從復制

# Redis集群配置示例
spring:redis:cluster:nodes:- 192.168.1.100:7001- 192.168.1.100:7002- 192.168.1.100:7003- 192.168.1.101:7001- 192.168.1.101:7002- 192.168.1.101:7003max-redirects: 3timeout: 3000mslettuce:pool:max-active: 16max-idle: 8min-idle: 0

方案3：熔斷降級機制

@Component
public class ProductServiceWithCircuitBreaker {private RedisTemplate<String, Object> redisTemplate;private ProductRepository productRepository;private CircuitBreaker circuitBreaker;public ProductServiceWithCircuitBreaker() {// 配置熔斷器this.circuitBreaker = CircuitBreaker.ofDefaults("productService");circuitBreaker.getEventPublisher().onStateTransition(event ->System.out.println("CircuitBreaker state transition: " + event));}public Product getProductById(Long productId) {return circuitBreaker.executeSupplier(() -> {String key = "product:" + productId;Product product = (Product) redisTemplate.opsForValue().get(key);if (product == null) {product = productRepository.findById(productId);if (product != null) {redisTemplate.opsForValue().set(key, product, Duration.ofMinutes(30));}}return product;});}
}

方案4：本地緩存兜底

@Service
public class ProductServiceWithLocalCache {private RedisTemplate<String, Object> redisTemplate;private ProductRepository productRepository;private Cache<String, Product> localCache;public ProductServiceWithLocalCache() {// 創建本地緩存this.localCache = Caffeine.newBuilder().maximumSize(1000).expireAfterWrite(5, TimeUnit.MINUTES).build();}public Product getProductById(Long productId) {String key = "product:" + productId;try {// 1. 先查Redis緩存Product product = (Product) redisTemplate.opsForValue().get(key);if (product != null) {// 同時更新本地緩存localCache.put(key, product);return product;}} catch (Exception e) {// Redis異常時，查詢本地緩存Product localProduct = localCache.getIfPresent(key);if (localProduct != null) {return localProduct;}}// 2. 查詢數據庫Product product = productRepository.findById(productId);if (product != null) {try {redisTemplate.opsForValue().set(key, product, Duration.ofMinutes(30));} catch (Exception e) {// Redis寫入失敗，只更新本地緩存localCache.put(key, product);}}return product;}
}

2.5 緩存雪崩預防最佳實踐

@Configuration
public class CacheConfiguration {@Beanpublic RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory connectionFactory) {RedisTemplate<String, Object> template = new RedisTemplate<>();template.setConnectionFactory(connectionFactory);// 設置序列化方式template.setKeySerializer(new StringRedisSerializer());template.setValueSerializer(new GenericJackson2JsonRedisSerializer());return template;}@Beanpublic CacheManager cacheManager(RedisConnectionFactory connectionFactory) {RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofMinutes(30)) // 默認30分鐘過期.disableCachingNullValues();return RedisCacheManager.builder(connectionFactory).cacheDefaults(config).build();}
}

3. 緩存穿透 (Cache Penetration)

3.1 什么是緩存穿透

緩存穿透是指查詢一個一定不存在的數據，由于緩存是不命中時才查詢數據庫，而且不存在的數據不會寫入緩存，導致這個不存在的數據每次請求都要查詢數據庫，給數據庫造成壓力。

3.2 緩存穿透的場景示例

// 問題代碼示例
public User getUserById(Long userId) {String key = "user:" + userId;// 1. 查緩存User user = (User) redisTemplate.opsForValue().get(key);if (user != null) {return user;}// 2. 查數據庫user = userRepository.findById(userId);if (user != null) {// 3. 只有數據存在才緩存redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));}// 如果user為null，不緩存，下次還會查數據庫return user;
}

3.3 緩存穿透的危害

• 大量無效請求穿透到數據庫
• 數據庫查詢壓力增大
• 系統整體性能下降
• 可能被惡意攻擊利用

3.4 緩存穿透的解決方案

方案1：緩存空值

@Service
public class UserServiceWithNullCache {private RedisTemplate<String, Object> redisTemplate;private UserRepository userRepository;public User getUserById(Long userId) {String key = "user:" + userId;// 1. 查緩存Object cached = redisTemplate.opsForValue().get(key);if (cached != null) {// 如果是特殊標記，說明數據不存在if ("NULL".equals(cached)) {return null;}return (User) cached;}// 2. 查數據庫User user = userRepository.findById(userId);if (user != null) {// 3. 緩存有效數據redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));} else {// 4. 緩存空值，但設置較短的過期時間redisTemplate.opsForValue().set(key, "NULL", Duration.ofMinutes(5));}return user;}
}

方案2：布隆過濾器

@Service
public class UserServiceWithBloomFilter {private RedisTemplate<String, Object> redisTemplate;private UserRepository userRepository;private BloomFilter<Long> bloomFilter;@PostConstructpublic void initBloomFilter() {// 創建布隆過濾器，預計100萬個元素，誤判率0.01%bloomFilter = BloomFilter.create(Funnels.longFunnel(), 1000000, 0.0001);// 將所有用戶ID加入布隆過濾器List<Long> userIds = userRepository.findAllUserIds();userIds.forEach(bloomFilter::put);}public User getUserById(Long userId) {// 1. 先用布隆過濾器判斷if (!bloomFilter.mightContain(userId)) {// 布隆過濾器說不存在，一定不存在return null;}String key = "user:" + userId;// 2. 查緩存User user = (User) redisTemplate.opsForValue().get(key);if (user != null) {return user;}// 3. 查數據庫user = userRepository.findById(userId);if (user != null) {redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));}return user;}
}

方案3：參數校驗

@RestController
public class UserController {private UserService userService;@GetMapping("/user/{userId}")public ResponseEntity<User> getUser(@PathVariable Long userId) {// 1. 參數校驗if (userId == null || userId <= 0) {return ResponseEntity.badRequest().build();}// 2. 業務范圍校驗if (userId > 999999999L) { // 假設用戶ID不會超過這個值return ResponseEntity.notFound().build();}User user = userService.getUserById(userId);return user != null ? ResponseEntity.ok(user) : ResponseEntity.notFound().build();}
}

方案4：接口限流

@Component
public class RateLimitInterceptor implements HandlerInterceptor {private RateLimiter rateLimiter = RateLimiter.create(100); // 每秒100個請求@Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {if (!rateLimiter.tryAcquire(1, TimeUnit.SECONDS)) {response.setStatus(HttpStatus.TOO_MANY_REQUESTS.value());response.getWriter().write("請求過于頻繁，請稍后再試");return false;}return true;}
}

3.5 Redis布隆過濾器實現

@Component
public class RedisBloomFilter {private RedisTemplate<String, Object> redisTemplate;private static final String BF_KEY_PREFIX = "bf:";/*** 添加元素到布隆過濾器*/public void add(String filterName, String value) {String key = BF_KEY_PREFIX + filterName;int[] hashes = getHashes(value);for (int hash : hashes) {redisTemplate.opsForValue().setBit(key, Math.abs(hash), true);}// 設置過期時間redisTemplate.expire(key, Duration.ofDays(7));}/*** 判斷元素是否可能存在*/public boolean mightContain(String filterName, String value) {String key = BF_KEY_PREFIX + filterName;int[] hashes = getHashes(value);for (int hash : hashes) {if (!redisTemplate.opsForValue().getBit(key, Math.abs(hash))) {return false;}}return true;}/*** 生成多個哈希值*/private int[] getHashes(String value) {int[] hashes = new int[3]; // 使用3個哈希函數int hash1 = value.hashCode();int hash2 = hash1 >>> 16;for (int i = 0; i < 3; i++) {hashes[i] = hash1 + i * hash2;}return hashes;}
}

4. 緩存預熱 (Cache Warming)

4.1 什么是緩存預熱

緩存預熱是指在系統啟動或者在業務高峰期之前，提前將熱點數據加載到緩存中，避免在業務高峰期時因為緩存未命中而導致大量請求打到數據庫上。

4.2 緩存預熱的時機

• 系統啟動時：應用啟動完成后立即預熱
• 定時預熱：在業務低峰期定時刷新緩存
• 手動預熱：通過管理接口手動觸發預熱

4.3 緩存預熱的策略

策略1：啟動時預熱

@Component
public class CacheWarmUpService {private RedisTemplate<String, Object> redisTemplate;private ProductRepository productRepository;private UserRepository userRepository;@EventListener(ApplicationReadyEvent.class)public void warmUpCache() {System.out.println("開始緩存預熱...");// 預熱熱門商品warmUpHotProducts();// 預熱活躍用戶warmUpActiveUsers();// 預熱系統配置warmUpSystemConfig();System.out.println("緩存預熱完成!");}private void warmUpHotProducts() {List<Product> hotProducts = productRepository.findHotProducts(100);for (Product product : hotProducts) {String key = "product:" + product.getId();redisTemplate.opsForValue().set(key, product, Duration.ofHours(2));}System.out.println("熱門商品預熱完成，共預熱 " + hotProducts.size() + " 個商品");}private void warmUpActiveUsers() {List<User> activeUsers = userRepository.findActiveUsers(1000);for (User user : activeUsers) {String key = "user:" + user.getId();redisTemplate.opsForValue().set(key, user, Duration.ofHours(1));}System.out.println("活躍用戶預熱完成，共預熱 " + activeUsers.size() + " 個用戶");}private void warmUpSystemConfig() {Map<String, Object> configs = getSystemConfigs();configs.forEach((key, value) -> {redisTemplate.opsForValue().set("config:" + key, value, Duration.ofDays(1));});System.out.println("系統配置預熱完成");}private Map<String, Object> getSystemConfigs() {// 模擬獲取系統配置Map<String, Object> configs = new HashMap<>();configs.put("max_order_amount", 50000);configs.put("free_shipping_threshold", 100);configs.put("vip_discount_rate", 0.9);return configs;}
}

策略2：分批預熱

@Service
public class BatchCacheWarmUpService {private RedisTemplate<String, Object> redisTemplate;private ProductRepository productRepository;private TaskExecutor taskExecutor;public void warmUpProductsInBatches() {int totalCount = productRepository.countAllProducts();int batchSize = 100;int totalBatches = (totalCount + batchSize - 1) / batchSize;System.out.println("開始分批預熱商品緩存，總數：" + totalCount + "，批次數：" + totalBatches);for (int i = 0; i < totalBatches; i++) {final int batchIndex = i;taskExecutor.execute(() -> {List<Product> products = productRepository.findProductsByPage(batchIndex * batchSize, batchSize);for (Product product : products) {String key = "product:" + product.getId();redisTemplate.opsForValue().set(key, product, Duration.ofHours(2));}System.out.println("第 " + (batchIndex + 1) + " 批預熱完成，預熱了 " + products.size() + " 個商品");});// 控制預熱速度，避免對系統造成壓力try {Thread.sleep(100);} catch (InterruptedException e) {Thread.currentThread().interrupt();}}}
}

策略3：定時預熱

@Component
public class ScheduledCacheWarmUp {private RedisTemplate<String, Object> redisTemplate;private ProductRepository productRepository;/*** 每天凌晨2點預熱熱門商品緩存*/@Scheduled(cron = "0 0 2 * * ?")public void scheduledWarmUp() {System.out.println("開始定時緩存預熱...");// 獲取熱門商品List<Product> hotProducts = productRepository.findHotProductsByLastWeek(200);for (Product product : hotProducts) {String key = "product:" + product.getId();// 設置不同的過期時間，避免同時失效int randomHours = 12 + new Random().nextInt(12); // 12-24小時redisTemplate.opsForValue().set(key, product, Duration.ofHours(randomHours));}System.out.println("定時預熱完成，預熱了 " + hotProducts.size() + " 個熱門商品");}/*** 每小時更新一次實時排行榜*/@Scheduled(fixedRate = 3600000) // 1小時public void updateRankingCache() {// 更新銷量排行榜List<Product> topSelling = productRepository.findTopSellingProducts(50);redisTemplate.opsForList().leftPushAll("ranking:top_selling", topSelling.toArray());redisTemplate.expire("ranking:top_selling", Duration.ofHours(2));// 更新熱門搜索榜List<String> hotKeywords = getHotSearchKeywords();redisTemplate.opsForList().leftPushAll("ranking:hot_keywords", hotKeywords.toArray());redisTemplate.expire("ranking:hot_keywords", Duration.ofHours(1));}private List<String> getHotSearchKeywords() {// 模擬獲取熱門搜索關鍵詞return Arrays.asList("手機", "電腦", "耳機", "鍵盤", "鼠標");}
}

策略4：智能預熱

@Service
public class IntelligentCacheWarmUp {private RedisTemplate<String, Object> redisTemplate;private ProductRepository productRepository;private AnalyticsService analyticsService;/*** 基于用戶行為數據的智能預熱*/public void intelligentWarmUp() {// 1. 分析用戶訪問模式Map<Long, Integer> productAccessCount = analyticsService.getProductAccessCount(Duration.ofDays(7));// 2. 按訪問量排序List<Map.Entry<Long, Integer>> sortedProducts = productAccessCount.entrySet().stream().sorted(Map.Entry.<Long, Integer>comparingByValue().reversed()).limit(500).collect(Collectors.toList());// 3. 分級預熱for (int i = 0; i < sortedProducts.size(); i++) {Long productId = sortedProducts.get(i).getKey();Integer accessCount = sortedProducts.get(i).getValue();Product product = productRepository.findById(productId);if (product != null) {String key = "product:" + productId;Duration expireTime = calculateExpireTime(i, accessCount);redisTemplate.opsForValue().set(key, product, expireTime);}}}/*** 根據商品熱度計算過期時間*/private Duration calculateExpireTime(int rank, int accessCount) {if (rank < 50) {return Duration.ofHours(24); // 最熱門的商品緩存24小時} else if (rank < 200) {return Duration.ofHours(12); // 次熱門商品緩存12小時} else {return Duration.ofHours(6);  // 一般熱門商品緩存6小時}}
}

4.4 預熱監控和管理

@RestController
@RequestMapping("/cache/warmup")
public class CacheWarmUpController {private BatchCacheWarmUpService batchWarmUpService;private IntelligentCacheWarmUp intelligentWarmUp;private RedisTemplate<String, Object> redisTemplate;/*** 手動觸發預熱*/@PostMapping("/manual")public ResponseEntity<String> manualWarmUp(@RequestParam String type) {try {switch (type) {case "product":batchWarmUpService.warmUpProductsInBatches();break;case "intelligent":intelligentWarmUp.intelligentWarmUp();break;default:return ResponseEntity.badRequest().body("不支持的預熱類型");}return ResponseEntity.ok("預熱任務已啟動");} catch (Exception e) {return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("預熱失敗：" + e.getMessage());}}/*** 查看緩存狀態*/@GetMapping("/status")public ResponseEntity<Map<String, Object>> getCacheStatus() {Map<String, Object> status = new HashMap<>();// 統計不同類型緩存的數量Set<String> productKeys = redisTemplate.keys("product:*");Set<String> userKeys = redisTemplate.keys("user:*");Set<String> configKeys = redisTemplate.keys("config:*");status.put("productCacheCount", productKeys != null ? productKeys.size() : 0);status.put("userCacheCount", userKeys != null ? userKeys.size() : 0);status.put("configCacheCount", configKeys != null ? configKeys.size() : 0);status.put("timestamp", System.currentTimeMillis());return ResponseEntity.ok(status);}/*** 清空指定類型的緩存*/@DeleteMapping("/clear")public ResponseEntity<String> clearCache(@RequestParam String type) {try {Set<String> keys = redisTemplate.keys(type + ":*");if (keys != null && !keys.isEmpty()) {redisTemplate.delete(keys);return ResponseEntity.ok("已清空 " + keys.size() + " 個 " + type + " 類型的緩存");} else {return ResponseEntity.ok("沒有找到 " + type + " 類型的緩存");}} catch (Exception e) {return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("清空緩存失敗：" + e.getMessage());}}
}

5. 緩存更新 (Cache Update)

5.1 什么是緩存更新

緩存更新是指當數據發生變化時，需要同步更新緩存中的數據，確保緩存數據與數據庫數據的一致性。這是分布式系統中的一個重要問題，需要選擇合適的策略來處理。

5.2 緩存更新的策略

策略1：Cache Aside（旁路緩存）

這是最常用的緩存模式，應用程序直接與緩存和數據庫交互。

@Service
public class UserServiceCacheAside {private RedisTemplate<String, Object> redisTemplate;private UserRepository userRepository;/*** 讀取數據*/public User getUserById(Long userId) {String key = "user:" + userId;// 1. 先查緩存User user = (User) redisTemplate.opsForValue().get(key);if (user != null) {return user;}// 2. 緩存未命中，查數據庫user = userRepository.findById(userId);if (user != null) {// 3. 寫入緩存redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));}return user;}/*** 更新數據*/@Transactionalpublic void updateUser(User user) {// 1. 先更新數據庫userRepository.save(user);// 2. 刪除緩存String key = "user:" + user.getId();redisTemplate.delete(key);// 或者更新緩存// redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));}/*** 刪除數據*/@Transactionalpublic void deleteUser(Long userId) {// 1. 刪除數據庫數據userRepository.deleteById(userId);// 2. 刪除緩存String key = "user:" + userId;redisTemplate.delete(key);}
}

策略2：Write Through（寫透緩存）

數據同時寫入緩存和數據庫。

@Service
public class UserServiceWriteThrough {private RedisTemplate<String, Object> redisTemplate;private UserRepository userRepository;public User getUserById(Long userId) {String key = "user:" + userId;// 先查緩存User user = (User) redisTemplate.opsForValue().get(key);if (user != null) {return user;}// 緩存未命中，從數據庫加載并寫入緩存user = loadUserFromDatabase(userId);return user;}@Transactionalpublic void updateUser(User user) {try {// 1. 同時更新數據庫和緩存userRepository.save(user);String key = "user:" + user.getId();redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));} catch (Exception e) {// 如果任一操作失敗，需要回滾throw new RuntimeException("更新失敗", e);}}private User loadUserFromDatabase(Long userId) {User user = userRepository.findById(userId);if (user != null) {String key = "user:" + userId;redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));}return user;}
}

策略3：Write Behind（異步寫回）

數據先寫入緩存，然后異步寫入數據庫。

@Service
public class UserServiceWriteBehind {private RedisTemplate<String, Object> redisTemplate;private UserRepository userRepository;private TaskExecutor taskExecutor;private BlockingQueue<User> writeQueue = new LinkedBlockingQueue<>();@PostConstructpublic void startAsyncWriter() {// 啟動異步寫入線程taskExecutor.execute(this::processWriteQueue);}public User getUserById(Long userId) {String key = "user:" + userId;// 先查緩存User user = (User) redisTemplate.opsForValue().get(key);if (user != null) {return user;}// 從數據庫加載user = userRepository.findById(userId);if (user != null) {redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));}return user;}public void updateUser(User user) {// 1. 立即更新緩存String key = "user:" + user.getId();redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));// 2. 異步更新數據庫try {writeQueue.offer(user, 1, TimeUnit.SECONDS);} catch (InterruptedException e) {Thread.currentThread().interrupt();}}private void processWriteQueue() {while (true) {try {User user = writeQueue.take();userRepository.save(user);System.out.println("異步寫入數據庫完成：" + user.getId());} catch (InterruptedException e) {Thread.currentThread().interrupt();break;} catch (Exception e) {System.err.println("異步寫入失敗：" + e.getMessage());}}}
}

5.3 緩存一致性問題解決方案

方案1：延時雙刪

@Service
public class UserServiceDelayedDoubleDelete {private RedisTemplate<String, Object> redisTemplate;private UserRepository userRepository;private TaskExecutor taskExecutor;@Transactionalpublic void updateUser(User user) {String key = "user:" + user.getId();// 1. 先刪除緩存redisTemplate.delete(key);// 2. 更新數據庫userRepository.save(user);// 3. 延時再刪除一次緩存taskExecutor.execute(() -> {try {Thread.sleep(1000); // 延時1秒redisTemplate.delete(key);System.out.println("延時刪除緩存完成：" + key);} catch (InterruptedException e) {Thread.currentThread().interrupt();}});}
}

方案2：基于消息隊列的異步更新

@Service
public class UserServiceWithMQ {private RedisTemplate<String, Object> redisTemplate;private UserRepository userRepository;private RabbitTemplate rabbitTemplate;@Transactionalpublic void updateUser(User user) {// 1. 更新數據庫userRepository.save(user);// 2. 發送緩存更新消息CacheUpdateMessage message = new CacheUpdateMessage();message.setType("USER_UPDATE");message.setKey("user:" + user.getId());message.setUserId(user.getId());rabbitTemplate.convertAndSend("cache.update.exchange", "cache.update", message);}@RabbitListener(queues = "cache.update.queue")public void handleCacheUpdate(CacheUpdateMessage message) {try {if ("USER_UPDATE".equals(message.getType())) {// 刪除緩存，下次訪問時重新加載redisTemplate.delete(message.getKey());System.out.println("處理緩存更新消息：" + message.getKey());}} catch (Exception e) {System.err.println("處理緩存更新失敗：" + e.getMessage());}}public static class CacheUpdateMessage {private String type;private String key;private Long userId;// getter和setter方法...}
}

方案3：分布式鎖保證一致性

@Service
public class UserServiceWithDistributedLock {private RedisTemplate<String, Object> redisTemplate;private UserRepository userRepository;private RedissonClient redissonClient;@Transactionalpublic void updateUser(User user) {String lockKey = "lock:user:" + user.getId();RLock lock = redissonClient.getLock(lockKey);try {// 獲取分布式鎖if (lock.tryLock(10, TimeUnit.SECONDS)) {// 1. 更新數據庫userRepository.save(user);// 2. 刪除緩存String cacheKey = "user:" + user.getId();redisTemplate.delete(cacheKey);} else {throw new RuntimeException("獲取鎖失敗");}} catch (InterruptedException e) {Thread.currentThread().interrupt();} finally {if (lock.isHeldByCurrentThread()) {lock.unlock();}}}
}

5.4 緩存更新最佳實踐

實踐1：批量更新優化

@Service
public class BatchUpdateService {private RedisTemplate<String, Object> redisTemplate;private UserRepository userRepository;/*** 批量更新用戶數據*/@Transactionalpublic void batchUpdateUsers(List<User> users) {if (users == null || users.isEmpty()) {return;}// 1. 批量更新數據庫userRepository.saveAll(users);// 2. 批量刪除緩存List<String> cacheKeys = users.stream().map(user -> "user:" + user.getId()).collect(Collectors.toList());redisTemplate.delete(cacheKeys);System.out.println("批量更新完成，影響用戶數：" + users.size());}/*** 批量預熱緩存*/public void batchWarmUpUsers(List<Long> userIds) {List<User> users = userRepository.findAllById(userIds);// 使用Pipeline批量寫入RedisredisTemplate.executePipelined((RedisCallback<Object>) connection -> {for (User user : users) {String key = "user:" + user.getId();byte[] keyBytes = key.getBytes();byte[] valueBytes = serializeUser(user);connection.setEx(keyBytes, 1800, valueBytes); // 30分鐘過期}return null;});System.out.println("批量預熱完成，預熱用戶數：" + users.size());}private byte[] serializeUser(User user) {// 序列化用戶對象try {ObjectMapper mapper = new ObjectMapper();return mapper.writeValueAsBytes(user);} catch (Exception e) {throw new RuntimeException("序列化失敗", e);}}
}

6. 緩存降級 (Cache Degradation)

6.1 什么是緩存降級

緩存降級是指當緩存系統出現故障或性能問題時，系統自動切換到備用方案，確保系統的可用性。這是一種保障系統穩定性的重要機制。

6.2 緩存降級的場景

• 緩存服務器宕機：Redis服務器不可用
• 緩存響應超時：網絡延遲或服務器負載過高
• 緩存連接池耗盡：并發請求過多
• 緩存數據異常：數據損壞或格式錯誤

6.3 緩存降級策略

策略1：本地緩存降級

@Service
public class UserServiceWithLocalFallback {private RedisTemplate<String, Object> redisTemplate;private UserRepository userRepository;private Cache<String, User> localCache;private CircuitBreaker circuitBreaker;public UserServiceWithLocalFallback() {// 初始化本地緩存this.localCache = Caffeine.newBuilder().maximumSize(1000).expireAfterWrite(10, TimeUnit.MINUTES).build();// 初始化熔斷器this.circuitBreaker = CircuitBreaker.ofDefaults("redis");}public User getUserById(Long userId) {String key = "user:" + userId;// 1. 嘗試從Redis獲取數據User user = circuitBreaker.executeSupplier(() -> {return (User) redisTemplate.opsForValue().get(key);});if (user != null) {// 更新本地緩存localCache.put(key, user);return user;}// 2. Redis失敗，嘗試本地緩存user = localCache.getIfPresent(key);if (user != null) {System.out.println("使用本地緩存降級：" + key);return user;}// 3. 本地緩存也沒有，查詢數據庫user = userRepository.findById(userId);if (user != null) {// 同時更新本地緩存和Redis（如果可用）localCache.put(key, user);try {redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));} catch (Exception e) {System.out.println("Redis寫入失敗，僅使用本地緩存");}}return user;}
}

策略2：多級緩存降級

@Service
public class MultiLevelCacheService {private RedisTemplate<String, Object> redisTemplate;private UserRepository userRepository;private Cache<String, User> l1Cache; // 一級緩存（本地）private Cache<String, User> l2Cache; // 二級緩存（本地備份）public MultiLevelCacheService() {// L1緩存：小容量，短過期時間this.l1Cache = Caffeine.newBuilder().maximumSize(500).expireAfterWrite(5, TimeUnit.MINUTES).build();// L2緩存：大容量，長過期時間this.l2Cache = Caffeine.newBuilder().maximumSize(2000).expireAfterWrite(30, TimeUnit.MINUTES).build();}public User getUserById(Long userId) {String key = "user:" + userId;// 1. 查詢L1緩存User user = l1Cache.getIfPresent(key);if (user != null) {return user;}// 2. 查詢Redistry {user = (User) redisTemplate.opsForValue().get(key);if (user != null) {l1Cache.put(key, user);l2Cache.put(key, user);return user;}} catch (Exception e) {System.out.println("Redis查詢失敗，嘗試L2緩存");}// 3. 查詢L2緩存user = l2Cache.getIfPresent(key);if (user != null) {l1Cache.put(key, user);System.out.println("使用L2緩存降級：" + key);return user;}// 4. 查詢數據庫user = userRepository.findById(userId);if (user != null) {l1Cache.put(key, user);l2Cache.put(key, user);// 嘗試寫入Redistry {redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));} catch (Exception e) {System.out.println("Redis寫入失敗，僅使用本地緩存");}}return user;}
}

策略3：靜態數據降級

@Service
public class UserServiceWithStaticFallback {private RedisTemplate<String, Object> redisTemplate;private UserRepository userRepository;private Map<Long, User> staticUserCache;@PostConstructpublic void initStaticCache() {// 初始化靜態數據緩存（VIP用戶、管理員等重要用戶）List<User> vipUsers = userRepository.findVipUsers();staticUserCache = vipUsers.stream().collect(Collectors.toMap(User::getId, Function.identity()));System.out.println("靜態緩存初始化完成，VIP用戶數：" + vipUsers.size());}public User getUserById(Long userId) {String key = "user:" + userId;try {// 1. 嘗試RedisUser user = (User) redisTemplate.opsForValue().get(key);if (user != null) {return user;}} catch (Exception e) {System.out.println("Redis不可用，嘗試降級方案");}// 2. 檢查靜態緩存（重要用戶）User staticUser = staticUserCache.get(userId);if (staticUser != null) {System.out.println("使用靜態緩存降級：" + userId);return staticUser;}// 3. 查詢數據庫return userRepository.findById(userId);}/*** 定期更新靜態緩存*/@Scheduled(fixedRate = 3600000) // 每小時更新public void refreshStaticCache() {try {List<User> vipUsers = userRepository.findVipUsers();Map<Long, User> newCache = vipUsers.stream().collect(Collectors.toMap(User::getId, Function.identity()));this.staticUserCache = newCache;System.out.println("靜態緩存刷新完成");} catch (Exception e) {System.err.println("靜態緩存刷新失敗：" + e.getMessage());}}
}

策略4：限流降級

@Service
public class UserServiceWithRateLimit {private RedisTemplate<String, Object> redisTemplate;private UserRepository userRepository;private RateLimiter rateLimiter;private AtomicBoolean degraded = new AtomicBoolean(false);public UserServiceWithRateLimit() {// 限流器：每秒允許100個Redis請求this.rateLimiter = RateLimiter.create(100);}public User getUserById(Long userId) {String key = "user:" + userId;// 檢查是否需要降級if (!degraded.get() && rateLimiter.tryAcquire()) {try {User user = (User) redisTemplate.opsForValue().get(key);if (user != null) {return user;}} catch (Exception e) {System.out.println("Redis異常，啟用降級模式");degraded.set(true);// 10秒后嘗試恢復scheduleRecovery();}}// 降級：直接查詢數據庫if (degraded.get()) {System.out.println("降級模式：直接查詢數據庫");} else {System.out.println("限流降級：跳過緩存查詢");}return userRepository.findById(userId);}private void scheduleRecovery() {CompletableFuture.delayedExecutor(10, TimeUnit.SECONDS).execute(() -> {try {// 測試Redis連接redisTemplate.opsForValue().get("test:connection");degraded.set(false);System.out.println("Redis恢復正常，退出降級模式");} catch (Exception e) {System.out.println("Redis仍不可用，繼續降級模式");}});}
}

6.4 降級監控和告警

監控組件

@Component
public class CacheMonitor {private RedisTemplate<String, Object> redisTemplate;private MeterRegistry meterRegistry;private Counter cacheHitCounter;private Counter cacheMissCounter;private Counter degradationCounter;public CacheMonitor(MeterRegistry meterRegistry) {this.meterRegistry = meterRegistry;this.cacheHitCounter = Counter.builder("cache.hit").description("Cache hit count").register(meterRegistry);this.cacheMissCounter = Counter.builder("cache.miss").description("Cache miss count").register(meterRegistry);this.degradationCounter = Counter.builder("cache.degradation").description("Cache degradation count").register(meterRegistry);}public void recordCacheHit() {cacheHitCounter.increment();}public void recordCacheMiss() {cacheMissCounter.increment();}public void recordDegradation(String reason) {degradationCounter.increment(Tags.of("reason", reason));}/*** 健康檢查*/@Scheduled(fixedRate = 30000) // 每30秒檢查public void healthCheck() {try {redisTemplate.opsForValue().get("health:check");System.out.println("Redis健康檢查：正常");} catch (Exception e) {System.err.println("Redis健康檢查：異常 - " + e.getMessage());recordDegradation("health_check_failed");}}/*** 獲取緩存統計信息*/public Map<String, Object> getCacheStats() {Map<String, Object> stats = new HashMap<>();stats.put("hitCount", cacheHitCounter.count());stats.put("missCount", cacheMissCounter.count());stats.put("degradationCount", degradationCounter.count());double hitRate = 0.0;double totalRequests = cacheHitCounter.count() + cacheMissCounter.count();if (totalRequests > 0) {hitRate = cacheHitCounter.count() / totalRequests;}stats.put("hitRate", hitRate);return stats;}
}

6.5 降級策略配置化

@ConfigurationProperties(prefix = "cache.degradation")
@Component
public class CacheDegradationConfig {private boolean enabled = true;private int timeoutMs = 1000;private int maxRetries = 3;private boolean useLocalCache = true;private boolean useStaticCache = true;private int recoveryDelaySeconds = 10;// getter和setter方法...
}@Service
public class ConfigurableCacheService {private RedisTemplate<String, Object> redisTemplate;private UserRepository userRepository;private CacheDegradationConfig config;private Cache<String, User> localCache;public User getUserById(Long userId) {String key = "user:" + userId;if (config.isEnabled()) {try {// 設置超時時間User user = getFromRedisWithTimeout(key, config.getTimeoutMs());if (user != null) {return user;}} catch (Exception e) {return handleDegradation(userId, key, e);}}// 直接查詢數據庫return userRepository.findById(userId);}private User getFromRedisWithTimeout(String key, int timeoutMs) {// 實現帶超時的Redis查詢CompletableFuture<User> future = CompletableFuture.supplyAsync(() -> {return (User) redisTemplate.opsForValue().get(key);});try {return future.get(timeoutMs, TimeUnit.MILLISECONDS);} catch (TimeoutException e) {throw new RuntimeException("Redis查詢超時", e);} catch (Exception e) {throw new RuntimeException("Redis查詢失敗", e);}}private User handleDegradation(Long userId, String key, Exception e) {System.out.println("Redis異常，啟用降級策略：" + e.getMessage());// 嘗試本地緩存if (config.isUseLocalCache()) {User user = localCache.getIfPresent(key);if (user != null) {System.out.println("使用本地緩存降級");return user;}}// 查詢數據庫return userRepository.findById(userId);}
}

7. 緩存最佳實踐總結

7.1 設計原則

1. 緩存穿透防護：使用布隆過濾器和空值緩存
2. 緩存雪崩防護：設置隨機過期時間和多級緩存
3. 數據一致性：選擇合適的緩存更新策略
4. 降級保護：設計多層降級方案
5. 監控告警：實時監控緩存狀態

7.2 性能優化

• 使用批量操作減少網絡開銷
• 合理設置連接池大小
• 選擇合適的序列化方式
• 控制緩存key的大小和數量

7.3 運維建議

• 定期備份重要緩存數據
• 監控緩存命中率和響應時間
• 設置合理的內存使用限制
• 建立緩存故障處理流程

通過學習這個詳細的緩存教程，你應該能夠：

• 理解各種緩存問題的原因和影響
• 掌握多種解決方案的實現方法
• 根據業務場景選擇合適的緩存策略
• 設計可靠的緩存降級機制
• 建立完善的緩存監控體系

記住，緩存是一把雙刃劍，正確使用能大幅提升系統性能，但處理不當也可能帶來數據一致性問題。在實際應用中，需要根據具體的業務場景和技術要求，選擇最適合的緩存策略。