Caffeine.newBuilder()
    .maximumSize(10_000)
    .weigher((String key, String value) -> value.length())
    .maximumWeight(50_000_000) // ~50MB
    .build();

<!-- Caffeine核心依賴（必選） -->
<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
    <version>3.2.7</version>  <!-- 截至2024年1月最新穩(wěn)定版 -->
    <!-- 建議通過dependencyManagement統(tǒng)一管理版本 -->
</dependency>
<!-- 異步支持依賴（可選） -->
<!-- 當(dāng)需要配合Java11+的HttpClient實(shí)現(xiàn)異步緩存加載時(shí)添加 -->
<dependency>
    <groupId>java.net.http</groupId>
    <artifactId>http-client</artifactId>
    <version>11.0.1</version>  <!-- 最低要求JDK11 -->
    <scope>runtime</scope>    <!-- 通常只需運(yùn)行時(shí)依賴 -->
</dependency>

dependencies {
    // 核心實(shí)現(xiàn)（必選）
    implementation("com.github.ben-manes.caffeine:caffeine:3.2.7")
    // 異步支持（可選）
    runtimeOnly("java.net.http:http-client:11.0.1") {
        because("For async cache loading with HTTP requests")
    }
}

Cache (基本功能)
├── LoadingCache (同步加載)
└── AsyncCache (異步基礎(chǔ))
    └── AsyncLoadingCache (異步加載)

import com.github.ben-manes.caffeine.cache.Caffeine;
import com.github.ben-manes.caffeine.cache.Cache;
import java.util.concurrent.TimeUnit;
public class CaffeineBasicDemo {
    public static void main(String[] args) {
        // 1. 配置并創(chuàng)建Cache實(shí)例（帶詳細(xì)注釋）
        Cache<String, String> userCache = Caffeine.newBuilder()
            .maximumSize(1000) // 最大容量1000條
            .expireAfterWrite(10, TimeUnit.MINUTES) // 寫入后10分鐘過期
            .expireAfterAccess(5, TimeUnit.MINUTES) // 訪問后5分鐘過期（優(yōu)先級(jí)低于expireAfterWrite）
            .removalListener((key, value, cause) -> { // 緩存移除監(jiān)聽器
                System.out.printf("緩存移除：key=%s, value=%s, 原因=%s%n",
                    key, value, cause.toString());
                // 原因可能是：EXPLICIT（手動(dòng)刪除）、REPLACED（值被替換）、
                // COLLECTED（垃圾回收）、EXPIRED（過期）、SIZE（超過容量限制）
            })
            .recordStats() // 啟用統(tǒng)計(jì)
            .build(); // 構(gòu)建Cache實(shí)例
        // 2. 寫入緩存（多種方式）
        userCache.put("user:1001", "張三"); // 常規(guī)put
        userCache.asMap().putIfAbsent("user:1002", "李四"); // 線程安全寫入
        // 3. 讀取緩存（未命中返回null）
        String user1 = userCache.getIfPresent("user:1001");
        System.out.println("讀取user:1001：" + user1); // 輸出：張三
        // 4. 讀取并計(jì)算（未命中時(shí)執(zhí)行函數(shù)邏輯，但不自動(dòng)存入緩存）
        String user3 = userCache.get("user:1003", key -> {
            // 模擬從數(shù)據(jù)庫查詢數(shù)據(jù)（僅當(dāng)緩存未命中時(shí)執(zhí)行）
            System.out.println("緩存未命中，查詢DB：" + key);
            return "王五"; // 此結(jié)果不會(huì)自動(dòng)存入緩存
        });
        System.out.println("讀取user:1003：" + user3); // 輸出：王五
        // 5. 緩存維護(hù)操作
        userCache.invalidate("user:1002"); // 單個(gè)刪除
        userCache.invalidateAll(List.of("user:1001", "user:1003")); // 批量刪除
        userCache.cleanUp(); // 手動(dòng)觸發(fā)清理過期條目
        userCache.invalidateAll(); // 清空所有緩存
        // 6. 查看統(tǒng)計(jì)信息（需先啟用recordStats）
        System.out.println("命中率：" + userCache.stats().hitRate());
    }
}

@Configuration
@EnableCaching
public class CacheConfig {
    @Bean
    public CacheManager cacheManager() {
        CaffeineCacheManager manager = new CaffeineCacheManager();
        manager.setCaffeine(Caffeine.newBuilder()
            .maximumSize(1000)
            .expireAfterWrite(10, TimeUnit.MINUTES));
        return manager;
    }
}

// 作為本地緩存與Redis組成二級(jí)緩存
public class MultiLevelCache {
    private final Cache<String, Object> localCache;
    private final RedisTemplate<String, Object> redisTemplate;
    public Object get(String key) {
        Object value = localCache.getIfPresent(key);
        if (value == null) {
            value = redisTemplate.opsForValue().get(key);
            if (value != null) {
                localCache.put(key, value);
            }
        }
        return value;
    }
}

import com.github.ben-manes.caffeine.cache.Caffeine;
import com.github.ben-manes.caffeine.cache.LoadingCache;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.List;
public class CaffeineLoadingDemo {
    public static void main(String[] args) throws ExecutionException {
        // 1. 實(shí)現(xiàn)CacheLoader：定義緩存未命中時(shí)的加載邏輯
        LoadingCache<String, String> productCache = Caffeine.newBuilder()
            .maximumSize(500)
            .expireAfterWrite(30, TimeUnit.MINUTES)
            .refreshAfterWrite(10, TimeUnit.MINUTES) // 10分鐘后刷新（不阻塞讀?。?
            .recordStats()
            .build(new CacheLoader<String, String>() {
                @Override
                public String load(String key) throws Exception {
                    // 模擬從數(shù)據(jù)庫加載數(shù)據(jù)（緩存未命中時(shí)自動(dòng)執(zhí)行）
                    System.out.println("緩存未命中，從DB加載：" + key);
                    if (key.startsWith("prod:")) {
                        return "商品-" + key.substring(5); // 如key=prod:101 → 商品-101
                    }
                    throw new IllegalArgumentException("Invalid key format");
                }
                // 可選：實(shí)現(xiàn)批量加載（提升getAll性能）
                @Override
                public Map<String, String> loadAll(Iterable<? extends String> keys) {
                    System.out.println("批量加載keys：" + keys);
                    // 實(shí)際應(yīng)從DB批量查詢
                    Map<String, String> result = new HashMap<>();
                    for (String key : keys) {
                        result.put(key, "商品-" + key.substring(5));
                    }
                    return result;
                }
            });
        // 2. 讀取緩存（未命中時(shí)自動(dòng)調(diào)用load()加載并存入緩存）
        String product1 = productCache.get("prod:101"); // 首次：加載并返回
        System.out.println("讀取prod:101：" + product1); // 輸出：商品-101
        // 3. 批量讀取（getAll()）
        Map<String, String> products = productCache.getAll(List.of("prod:102", "prod:103"));
        System.out.println("批量讀取結(jié)果：" + products);
        // 4. 主動(dòng)刷新（異步）
        productCache.refresh("prod:101"); // 后臺(tái)刷新，舊值仍可用
        // 5. 統(tǒng)計(jì)信息
        System.out.println("加載次數(shù)：" + productCache.stats().loadCount());
    }
}

// 商品詳情緩存：10分鐘強(qiáng)制過期，5分鐘自動(dòng)刷新
LoadingCache<String, Product> productCache = Caffeine.newBuilder()
    .maximumSize(10000)
    .expireAfterWrite(10, TimeUnit.MINUTES) // 強(qiáng)制過期時(shí)間
    .refreshAfterWrite(5, TimeUnit.MINUTES) // 自動(dòng)刷新時(shí)間
    .build(this::loadProductFromDB);

import com.github.ben-manes.caffeine.cache.AsyncLoadingCache;
import com.github.ben-manes.caffeine.cache.Caffeine;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
public class CaffeineAsyncDemo {
    public static void main(String[] args) throws Exception {
        // 1. 自定義線程池（生產(chǎn)環(huán)境建議使用有界隊(duì)列和拒絕策略）
        Executor executor = Executors.newFixedThreadPool(5, r -> {
            Thread thread = new Thread(r);
            thread.setName("caffeine-async-" + thread.getId());
            return thread;
        });
        // 2. 創(chuàng)建AsyncLoadingCache實(shí)例
        AsyncLoadingCache<String, String> orderCache = Caffeine.newBuilder()
            .maximumSize(1000)
            .expireAfterWrite(15, TimeUnit.MINUTES)
            .executor(executor) // 指定異步線程池
            .buildAsync(key -> {
                // 模擬耗時(shí)操作（如RPC調(diào)用，耗時(shí)200ms）
                TimeUnit.MILLISECONDS.sleep(200);
                System.out.println(Thread.currentThread().getName() + " 加載訂單：" + key);
                return "訂單-" + key.substring(6); // 如key=order:2024 → 訂單-2024
            });
        // 3. 異步讀取（推薦方式）
        CompletableFuture<String> future = orderCache.get("order:2024");
        future.thenApplyAsync(order -> {
            System.out.println("處理訂單數(shù)據(jù)：" + order);
            return order.toUpperCase();
        }, executor); // 使用相同線程池處理結(jié)果
        // 4. 批量讀?。ǚ祷豈ap<Key, CompletableFuture>）
        Map<String, CompletableFuture<String>> futures = 
            orderCache.getAll(List.of("order:2025", "order:2026"));
        // 5. 同步獲取（僅測(cè)試用，實(shí)際應(yīng)避免）
        String order = orderCache.get("order:2027").get();
        System.out.println("同步獲取結(jié)果：" + order);
    }
}

// 更完善的線程池配置
ThreadPoolExecutor executor = new ThreadPoolExecutor(
    5, // 核心線程數(shù)
    10, // 最大線程數(shù)
    60, TimeUnit.SECONDS, // 空閑線程存活時(shí)間
    new LinkedBlockingQueue<>(1000), // 有界隊(duì)列
    new ThreadFactoryBuilder().setNameFormat("cache-loader-%d").build(),
    new ThreadPoolExecutor.CallerRunsPolicy() // 拒絕策略
);

orderCache.get("badKey").exceptionally(ex -> {
    System.err.println("加載失敗: " + ex.getMessage());
    return "defaultValue";
});

@Cacheable(value = "orders", cacheManager = "asyncCacheManager")
public CompletableFuture<Order> getOrderAsync(String orderId) {
    return CompletableFuture.supplyAsync(() -> orderService.loadOrder(orderId));
}

CacheStats stats = orderCache.synchronous().stats();
System.out.println("平均加載時(shí)間：" + stats.averageLoadPenalty() + "ns");

import com.github.ben-manes.caffeine.cache.CacheStats;
public class CaffeineStatsDemo {
    public static void main(String[] args) {
        LoadingCache<String, String> statsCache = Caffeine.newBuilder()
            .maximumSize(100)
            .recordStats() // 必須顯式開啟統(tǒng)計(jì)功能
            .build(key -> {
                // 模擬耗時(shí)加載
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                return "統(tǒng)計(jì)測(cè)試：" + key;
            });
        // 模擬讀寫操作
        statsCache.get("key1");  // 第一次加載（未命中）
        statsCache.get("key1");  // 命中已有緩存
        statsCache.get("key2");  // 新鍵加載
        statsCache.invalidate("key1"); // 手動(dòng)失效
        // 獲取統(tǒng)計(jì)結(jié)果
        CacheStats stats = statsCache.stats();
        System.out.println("緩存命中率：" + stats.hitRate());  // 50%（1次命中/2次查詢）
        System.out.println("加載成功次數(shù)：" + stats.loadSuccessCount()); // 2次加載
        System.out.println("移除次數(shù)：" + stats.evictionCount()); // 0（未達(dá)到容量上限）
        System.out.println("平均加載耗時(shí)（ns）：" + stats.averageLoadPenalty()); // 約100ms
        System.out.println("加載失敗率：" + stats.loadFailureRate()); // 0.0
    }
}

import com.github.ben-manes.caffeine.cache.Caffeine;
import com.github.ben-manes.caffeine.cache.Expiry;
import com.github.ben-manes.caffeine.cache.LoadingCache;
import java.util.concurrent.TimeUnit;
class CustomExpiry implements Expiry<String, String> {
    @Override
    public long expireAfterCreate(String key, String value, long currentTime) {
        // 創(chuàng)建時(shí)過期策略
        if (key.startsWith("flash:")) {    // 閃存數(shù)據(jù)：30秒過期
            return TimeUnit.SECONDS.toNanos(30);
        } else if (key.startsWith("hot:")) { // 熱門數(shù)據(jù)：5分鐘
            return TimeUnit.MINUTES.toNanos(5);
        } else {                            // 普通數(shù)據(jù)：30分鐘
            return TimeUnit.MINUTES.toNanos(30);
        }
    }
    @Override
    public long expireAfterUpdate(String key, String value, 
            long currentTime, long currentDuration) {
        // 更新策略：保持原有過期時(shí)間（默認(rèn)）
        return currentDuration;
        // 或者重置為創(chuàng)建時(shí)間：return expireAfterCreate(key, value, currentTime);
    }
    @Override
    public long expireAfterRead(String key, String value, 
            long currentTime, long currentDuration) {
        // 讀取時(shí)策略：熱門數(shù)據(jù)讀取后續(xù)期5分鐘
        if (key.startsWith("hot:")) {
            return TimeUnit.MINUTES.toNanos(5);
        }
        return currentDuration;
    }
}
public class CaffeineCustomExpiryDemo {
    public static void main(String[] args) {
        LoadingCache<String, String> customExpiryCache = Caffeine.newBuilder()
            .expireAfter(new CustomExpiry())
            .build(key -> "自定義過期：" + key);
        customExpiryCache.get("flash:news:2023");   // 30秒過期
        customExpiryCache.get("hot:product:101");   // 5分鐘且讀取續(xù)期
        customExpiryCache.get("normal:user:201");   // 30分鐘過期
    }
}

// 弱引用Key+Value的緩存（適合臨時(shí)性數(shù)據(jù)）
Cache<String, byte[]> weakCache = Caffeine.newBuilder()
    .weakKeys()    // Key無強(qiáng)引用時(shí)回收
    .weakValues()  // Value無強(qiáng)引用時(shí)回收
    .maximumSize(10_000)  // 仍保持容量限制
    .build();
// 軟引用Value的緩存（適合大對(duì)象）
Cache<String, byte[]> softCache = Caffeine.newBuilder()
    .softValues()  // 內(nèi)存不足時(shí)回收Value
    .expireAfterWrite(1, TimeUnit.HOURS)  // 配合顯式過期
    .build();
// 典型使用場(chǎng)景
void processLargeData(String dataId) {
    byte[] data = softCache.get(dataId, id -> {
        // 從數(shù)據(jù)庫加載大對(duì)象（如圖片、文件等）
        return loadLargeDataFromDB(id); 
    });
    // 使用數(shù)據(jù)...
}

LoadingCache<String, String> cache = Caffeine.newBuilder()
    .expireAfterWrite(1, TimeUnit.MINUTES)  // 空值緩存1分鐘
    .build(key -> {
        String value = queryFromDB(key);
        // 特殊空值標(biāo)記，避免與真實(shí)空值混淆
        return value != null ? value : "NULL_VALUE";  
    });

// 初始化布隆過濾器
BloomFilter<String> bloomFilter = BloomFilter.create(
    Funnels.stringFunnel(Charset.defaultCharset()), 
    1000000,  // 預(yù)期元素?cái)?shù)量
    0.01      // 誤判率
);
// 查詢流程
if (!bloomFilter.mightContain(key)) {
    return null;  // 肯定不存在
} else {
    return cache.get(key);  // 可能存在
}

class CompositeKey {
    private Long id;
    private String category;
    // 缺少hashCode/equals實(shí)現(xiàn)
}
// 實(shí)際使用中
CompositeKey key1 = new CompositeKey(1L, "A");
CompositeKey key2 = new CompositeKey(1L, "A");
cache.put(key1, "value");
// 將返回null，因?yàn)閗ey2被視為不同key
cache.getIfPresent(key2); 

class CompositeKey implements Serializable {
    private final Long id;
    private final String category;
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof CompositeKey)) return false;
        CompositeKey that = (CompositeKey) o;
        return Objects.equals(id, that.id) && 
               Objects.equals(category, that.category);
    }
    @Override
    public int hashCode() {
        return Objects.hash(id, category);
    }
}

ExecutorService executor = Executors.newFixedThreadPool(
    Runtime.getRuntime().availableProcessors() * 2,
    new ThreadFactoryBuilder()
        .setNameFormat("caffeine-loader-%d")
        .setDaemon(true)
        .build()
);
AsyncLoadingCache<String, String> cache = Caffeine.newBuilder()
    .executor(executor)  // 指定專屬線程池
    .buildAsync(key -> loadExpensiveValue(key));

Caffeine.newBuilder()
    .maximumSize(10_000)  // 基于條目數(shù)限制
    .expireAfterWrite(30, TimeUnit.MINUTES)  // 寫入后30分鐘過期
    .expireAfterAccess(10, TimeUnit.MINUTES) // 10分鐘無訪問過期
    .weigher((String key, String value) -> value.length()) // 按value大小計(jì)算權(quán)重
    .maximumWeight(50_000_000)  // 約50MB內(nèi)存限制

LoadingCache<String, String> cache = Caffeine.newBuilder()
    .build(new CacheLoader<String, String>() {
        @Override
        public String load(String key) {
            try {
                return queryDB(key);
            } catch (SQLException e) {
                // 記錄詳細(xì)日志
                log.error("DB查詢失敗, key: {}", key, e);
                // 返回降級(jí)值
                return "DEFAULT_VALUE";
                // 或者拋出特定異常
                // throw new CacheLoadException(e);
            }
        }
    });
// 使用時(shí)的異常處理
try {
    return cache.get(key);
} catch (CacheLoaderException e) {
    // 處理加載失敗
    return processFallback(key);
} catch (Exception e) {
    // 兜底處理
    return "SYSTEM_ERROR";
}

// Guava Cache
LoadingCache<Key, Value> cache = CacheBuilder.newBuilder()
    .maximumSize(1000)
    .build(new CacheLoader<Key, Value>() {
        public Value load(Key key) {
            return createValue(key);
        }
    });
// 遷移到 Caffeine
LoadingCache<Key, Value> cache = Caffeine.newBuilder()
    .maximumSize(1000)
    .build(key -> createValue(key));

public class TwoLevelCacheService {
    private final Cache<String, Object> localCache = Caffeine.newBuilder()
        .maximumSize(10_000)
        .expireAfterWrite(30, TimeUnit.SECONDS)
        .build();
    private final RedisTemplate<String, Object> redisTemplate;
    public Object getData(String key) {
        // 1. 嘗試從本地緩存獲取
        Object value = localCache.getIfPresent(key);
        if (value != null) {
            return value;
        }
        // 2. 嘗試從Redis獲取
        value = redisTemplate.opsForValue().get(key);
        if (value != null) {
            localCache.put(key, value);
            return value;
        }
        // 3. 回源查詢
        value = queryDatabase(key);
        redisTemplate.opsForValue().set(key, value, 5, TimeUnit.MINUTES);
        localCache.put(key, value);
        return value;
    }
}

public Object getDataWithLock(String key) {
    Object value = cache.getIfPresent(key);
    if (value != null) {
        return value;
    }
    synchronized (key.intern()) {
        // 雙重檢查
        value = cache.getIfPresent(key);
        if (value != null) {
            return value;
        }
        try {
            value = queryDataSource(key);
            cache.put(key, value);
        } finally {
            // 釋放資源
        }
    }
    return value;
}

ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
scheduler.scheduleAtFixedRate(() -> {
    List<String> hotKeys = getHotKeyList();
    hotKeys.forEach(key -> {
        Object value = queryDataSource(key);
        cache.put(key, value);
    });
}, 0, 1, TimeUnit.MINUTES);

LoadingCache<String, Object> cache = Caffeine.newBuilder()
    .maximumSize(10_000)
    .refreshAfterWrite(1, TimeUnit.MINUTES)
    .build(key -> queryDataSource(key));