使用 Caffeine 和 Redis 實現高效的二級緩存架構
作者：微技術
本文將詳細介紹如何通過 Spring Boot 實現一個Caffeine + Redis 二級緩存，并通過合理的架構設計和代碼實現，確保緩存的一致性、性能和容錯性。
在現代應用開發中，緩存是提升系統性能的關鍵手段。為了兼顧本地緩存的高性能和分布式緩存的擴展能力，常見的實現方式是結合使用 Caffeine 和 Redis 實現二級緩存架構。
本文將詳細介紹如何通過 Spring Boot 實現一個Caffeine + Redis 二級緩存，并通過合理的架構設計和代碼實現，確保緩存的一致性、性能和容錯性。
一、 需求與挑戰
1.多級緩存的需求：
- 一級緩存（Caffeine）：快速響應，存儲本地熱點數據，減少對遠程緩存和數據庫的訪問。
- 二級緩存（Redis）：共享緩存數據，支持分布式擴展。
2.常見問題：
- 數據一致性：一級緩存和二級緩存之間的數據如何保持同步？
- 容錯性：Redis 不可用時如何保證系統穩定運行？
- 緩存穿透：如何避免大量無效請求穿透緩存直接訪問數據庫？
- 高并發：如何避免緩存擊穿導致數據庫壓力激增？
二、 緩存設計與解決方案
2.1 緩存查詢流程
按照Cache-Aside 模式，緩存查詢流程如下：
1.查詢一級緩存（Caffeine）：
如果命中，則直接返回結果。
2.查詢二級緩存（Redis）：
- 如果 Redis 有數據，則回填到一級緩存，并返回結果。
- 如果 Redis 查詢失敗（Redis 不可用），直接跳過。
3.查詢數據源（數據庫等）：
如果 Redis 也未命中，則從數據源獲取數據，同時回填到一級和二級緩存中。
2.2 緩存更新流程
- 數據更新或寫入時，同時更新一級和二級緩存。
- 如果 Redis 寫入失敗，僅更新一級緩存，確保數據可用性。
三、代碼實現
3.1 緩存接口設計
定義一個通用的緩存接口，便于不同實現類的擴展和切換：
import java.util.Collection;
import java.util.Map;
import java.util.Set;
import java.util.function.Supplier;
public interface CacheService {
<T> T get(String key, Class<T> type, Supplier<T> dataLoader); // 獲取單個鍵的數據
void put(String key, Object value); // 存儲單個鍵的數據
void evict(String key); // 刪除單個鍵
boolean exists(String key); // 檢查鍵是否存在
Map<String, Object> getAll(Set<String> keys); // 批量獲取多個鍵的數據
Object getHash(String key, String hashKey); // 獲取哈希表中單個字段的值
void putHash(String key, String hashKey, Object value); // 存儲哈希表中的字段
void evictAll(Collection<String> keys); // 批量刪除多個鍵
}3.2 Caffeine + Redis 實現
使用 Caffeine 和 Redis 的結合實現二級緩存：
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import java.util.concurrent.TimeUnit;
import java.util.function.Supplier;
@Service
public class OptimizedCacheService implements CacheService {
private final Cache<String, Object> caffeineCache;
private final RedisTemplate<String, Object> redisTemplate;
public OptimizedCacheService(RedisTemplate<String, Object> redisTemplate) {
this.caffeineCache = Caffeine.newBuilder()
.initialCapacity(100)
.maximumSize(1000)
.expireAfterWrite(10, TimeUnit.MINUTES)
.build();
this.redisTemplate = redisTemplate;
}
@Override
public <T> T get(String key, Class<T> type, Supplier<T> dataLoader) {
// Step 1: 查詢一級緩存（Caffeine）
T value = (T) caffeineCache.getIfPresent(key);
if (value != null) {
return value;
}
// Step 2: 查詢二級緩存（Redis）
try {
value = (T) redisTemplate.opsForValue().get(key);
if (value != null) {
// 回填到一級緩存
caffeineCache.put(key, value);
return value;
}
} catch (Exception e) {
// Redis 不可用時記錄日志
System.err.println("Redis 不可用：" + e.getMessage());
}
// Step 3: 查詢數據源（數據庫等）
value = dataLoader.get();
if (value != null) {
// 回填到緩存
caffeineCache.put(key, value);
try {
redisTemplate.opsForValue().set(key, value, 10, TimeUnit.MINUTES);
} catch (Exception e) {
System.err.println("Redis 存儲失?。? + e.getMessage());
}
}
return value;
}
@Override
public void put(String key, Object value) {
// 同時更新一級緩存和二級緩存
caffeineCache.put(key, value);
try {
redisTemplate.opsForValue().set(key, value, 10, TimeUnit.MINUTES);
} catch (Exception e) {
System.err.println("Redis 存儲失?。? + e.getMessage());
}
}
@Override
public void evict(String key) {
// 同時移除一級緩存和二級緩存
caffeineCache.invalidate(key);
try {
redisTemplate.delete(key);
} catch (Exception e) {
System.err.println("Redis 刪除失?。? + e.getMessage());
}
}
@Override
public boolean exists(String key) {
// 檢查一級緩存
if (caffeineCache.asMap().containsKey(key)) {
return true;
}
// 檢查二級緩存
try {
return Boolean.TRUE.equals(redisTemplate.hasKey(key));
} catch (Exception e) {
System.err.println("Redis 檢查鍵失?。? + e.getMessage());
return false;
}
}
@Override
public Map<String, Object> getAll(Set<String> keys) {
// 優先從一級緩存中獲取
Map<String, Object> result = caffeineCache.getAllPresent(keys);
// 還需要獲取的鍵
Set<String> missingKeys = keys.stream()
.filter(key -> !result.containsKey(key))
.collect(Collectors.toSet());
if (!missingKeys.isEmpty()) {
try {
// 從 Redis 獲取剩余的鍵
List<Object> redisResults = redisTemplate.opsForValue().multiGet(missingKeys);
if (redisResults != null) {
for (int i = 0; i < missingKeys.size(); i++) {
String key = missingKeys.toArray(new String[0])[i];
Object value = redisResults.get(i);
if (value != null) {
result.put(key, value);
caffeineCache.put(key, value); // 回填一級緩存
}
}
}
} catch (Exception e) {
System.err.println("Redis 批量獲取失敗：" + e.getMessage());
}
}
return result;
}
@Override
public Object getHash(String key, String hashKey) {
try {
return redisTemplate.opsForHash().get(key, hashKey);
} catch (Exception e) {
System.err.println("Redis 獲取哈希字段失?。? + e.getMessage());
return null;
}
}
@Override
public void putHash(String key, String hashKey, Object value) {
try {
redisTemplate.opsForHash().put(key, hashKey, value);
} catch (Exception e) {
System.err.println("Redis 存儲哈希字段失?。? + e.getMessage());
}
}
@Override
public void evictAll(Collection<String> keys) {
// 刪除一級緩存
caffeineCache.invalidateAll(keys);
// 刪除二級緩存
try {
redisTemplate.delete(keys);
} catch (Exception e) {
System.err.println("Redis 批量刪除失?。? + e.getMessage());
}
}
}3.3 空值緩存（防止緩存穿透）
為了避免查詢不存在的數據穿透到數據庫，可以將空值存儲到緩存中：
if (value == null) {
// 存儲空值到緩存，防止穿透
caffeineCache.put(key, "NULL");
try {
redisTemplate.opsForValue().set(key, "NULL", 1, TimeUnit.MINUTES);
} catch (Exception e) {
System.err.println("Redis 存儲空值失?。? + e.getMessage());
}
return null;
}
if ("NULL".equals(value)) {
return null;
}3.4 異步更新 Redis（提升寫性能）
為了提高寫操作性能，可以將 Redis 的更新操作放到異步線程中：
private void asyncUpdateRedis(String key, Object value) {
new Thread(() -> {
try {
redisTemplate.opsForValue().set(key, value, 10, TimeUnit.MINUTES);
} catch (Exception e) {
System.err.println("Redis 異步更新失?。? + e.getMessage());
}
}).start();
}在put和get方法中調用asyncUpdateRedis。
3.5 定時清理 Caffeine
Caffeine 默認是惰性清理（Lazy Cleanup）。如果需要主動清理，可以通過定時任務觸發：
@Scheduled(fixedRate = 60000) // 每分鐘執行一次
public void cleanUpCache() {
caffeineCache.cleanUp();
}
四、總結與優勢
4.1 架構特點
- 性能更高：直接按一級緩存 -> 二級緩存 -> 數據庫的順序查詢，減少了 Redis 可用性檢查的開銷。
- 降級容錯：當 Redis 不可用時，不影響數據加載和緩存更新。
- 緩存一致性：通過回填機制，盡量保持一級緩存和二級緩存的數據一致性。
- 可擴展性：支持空值緩存、異步更新、主動清理等增強功能。
4.2 應用場景
- 高頻訪問的數據（如熱門商品、熱點新聞）。
- 分布式應用需要共享緩存的數據。
- 對性能和容錯性有較高要求的業務場景。
通過 Caffeine 和 Redis 的結合，可以構建一個高效、靈活、穩定的二級緩存架構，有效提升系統性能并降低后端服務壓力。
責任編輯：華軒
來源：
微技術之家
