import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;

// 1. 創(chuàng)建緩存實(shí)例
Cache<String, Object> cache = Caffeine.newBuilder()
        .build();

// 2. 添加數(shù)據(jù)
cache.put("key1", "value1");

// 3. 獲取數(shù)據(jù)（手動(dòng)）
Object value = cache.getIfPresent("key1"); // 存在返回value，否則null

// 4. 刪除數(shù)據(jù)
cache.invalidate("key1");
cache.invalidateAll(); // 清空緩存

LoadingCache<String, Object> cache = Caffeine.newBuilder()
        .build(key -> {
            // 緩存未命中時(shí)自動(dòng)執(zhí)行的加載邏輯
            return fetchFromDB(key); // 自定義數(shù)據(jù)庫加載方法
        });

// 自動(dòng)加載數(shù)據(jù)（緩存未命中時(shí)執(zhí)行build中的邏輯）
Object value = cache.get("user_123");

Cache<String, Object> cache = Caffeine.newBuilder()
        // 寫入后30分鐘過期
        .expireAfterWrite(30, TimeUnit.MINUTES)
        
        // 最后訪問后15分鐘過期
        .expireAfterAccess(15, TimeUnit.MINUTES)
        
        // 自定義過期策略（按需實(shí)現(xiàn)）
        .expireAfter(new Expiry<String, Object>() {
            public long expireAfterCreate(String key, Object value, long currentTime) {
                return TimeUnit.MINUTES.toNanos(10); // 創(chuàng)建后10分鐘過期
            }
            public long expireAfterUpdate(String key, Object value, long currentTime, long currentDuration) {
                return currentDuration; // 更新后不改變過期時(shí)間
            }
            public long expireAfterRead(String key, Object value, long currentTime, long currentDuration) {
                return currentDuration; // 讀取后不改變過期時(shí)間
            }
        })
        .build();

// 創(chuàng)建支持變長過期的緩存
Cache<String, Object> cache = Caffeine.newBuilder()
        .expireAfter(new Expiry<String, Object>() {
            // ...實(shí)現(xiàn)同上
        })
        .build();

// 為特定Key設(shè)置不同過期時(shí)間
cache.policy().expireVariably().ifPresent(policy -> {
    policy.put("hot_key", "value", 2, TimeUnit.HOURS);  // 2小時(shí)
    policy.put("cold_key", "value", 10, TimeUnit.MINUTES); // 10分鐘
});

Cache<String, Object> cache = Caffeine.newBuilder()
        // 基于數(shù)量淘汰（最多1000個(gè)條目）
        .maximumSize(1000)
        
        // 基于權(quán)重淘汰（需實(shí)現(xiàn)Weigher）
        .maximumWeight(10_000)
        .weigher((String key, Object value) -> {
            // 自定義權(quán)重計(jì)算邏輯
            if (value instanceof String) return ((String) value).length();
            if (value instanceof List) return ((List<?>) value).size();
            return 1;
        })
        
        // 基于引用回收（謹(jǐn)慎使用）
        .weakKeys()      // 弱引用Key
        .weakValues()    // 弱引用Value
        .softValues()    // 軟引用Value
        .build();

LoadingCache<String, Object> cache = Caffeine.newBuilder()
        // 寫入后1分鐘可刷新（不阻塞讀取，異步刷新舊值）
        .refreshAfterWrite(1, TimeUnit.MINUTES)
        .build(key -> fetchFromDB(key));

Cache<String, Object> cache = Caffeine.newBuilder()
        // 移除監(jiān)聽器
        .removalListener((String key, Object value, RemovalCause cause) -> {
            System.out.printf("Key %s was removed (%s)%n", key, cause);
        })
        // 啟用統(tǒng)計(jì)
        .recordStats()
        .build();

// 獲取統(tǒng)計(jì)信息
CacheStats stats = cache.stats();
System.out.printf("Hit Rate: %.2f%%, Loads: %d%n",
        stats.hitRate() * 100, stats.loadCount());

// 1. 異步緩存
AsyncLoadingCache<String, Object> asyncCache = Caffeine.newBuilder()
        .buildAsync(key -> fetchFromDB(key));

// 獲取數(shù)據(jù)（返回CompletableFuture）
CompletableFuture<Object> future = asyncCache.get("key1");

// 2. 同步視圖操作
Object value = asyncCache.synchronous().get("key1");

LoadingCache<String, Object> optimalCache = Caffeine.newBuilder()
        // 容量控制
        .maximumSize(10_000)
        
        // 過期策略
        .expireAfterWrite(30, TimeUnit.MINUTES)
        
        // 刷新策略
        .refreshAfterWrite(5, TimeUnit.MINUTES)
        
        // 統(tǒng)計(jì)和監(jiān)聽
        .recordStats()
        .removalListener((key, value, cause) -> 
            logRemoval(key, cause))
        
        // 自動(dòng)加載
        .build(key -> fetchFromDB(key));

import com.github.benmanes.caffeine.cache.*;
import java.util.concurrent.TimeUnit;

public class DynamicCache<K, V> {

    private final Cache<K, V> cache;
    private final DataLoader<K, V> dataLoader;
    private final DataSynchronizer<K, V> dataSynchronizer;

    public DynamicCache(DataLoader<K, V> dataLoader, DataSynchronizer<K, V> dataSynchronizer) {
        this.dataLoader = dataLoader;
        this.dataSynchronizer = dataSynchronizer;
        
        this.cache = Caffeine.newBuilder()
                // 配置緩存策略（按需設(shè)置）
                .expireAfterWrite(30, TimeUnit.MINUTES)  // 30分鐘過期
                .maximumSize(1000)                      // 最大緩存項(xiàng)
                // 注冊(cè)移除監(jiān)聽器（用于刪除數(shù)據(jù)庫數(shù)據(jù)）
                .removalListener((K key, V value, RemovalCause cause) -> {
                    if (cause.wasEvicted()) {  // 僅處理過期或容量剔除
                        dataSynchronizer.deleteFromDatabase(key);
                    }
                })
                // 注冊(cè)加載器（用于緩存未命中時(shí)從DB加載）
                .build(key -> {
                    V value = dataLoader.loadFromDatabase(key);
                    if (value == null) throw new Exception("Key not found");
                    return value;
                });
    }

    // 獲取數(shù)據(jù)（自動(dòng)加載）
    public V get(K key) {
        return cache.get(key, k -> {
            V value = dataLoader.loadFromDatabase(k);
            if (value == null) throw new RuntimeException("Data not found");
            return value;
        });
    }

    // 添加/更新數(shù)據(jù)（同步到數(shù)據(jù)庫）
    public void put(K key, V value) {
        // 先同步到數(shù)據(jù)庫
        dataSynchronizer.saveToDatabase(key, value);
        // 再更新緩存
        cache.put(key, value);
    }

    // 刪除數(shù)據(jù)（同步刪除數(shù)據(jù)庫）
    public void delete(K key) {
        // 先刪除數(shù)據(jù)庫數(shù)據(jù)
        dataSynchronizer.deleteFromDatabase(key);
        // 再使緩存失效
        cache.invalidate(key);
    }

    // 數(shù)據(jù)庫加載器接口
    public interface DataLoader<K, V> {
        V loadFromDatabase(K key);
    }

    // 數(shù)據(jù)庫同步器接口
    public interface DataSynchronizer<K, V> {
        void saveToDatabase(K key, V value);
        void deleteFromDatabase(K key);
    }
}

// 1. 實(shí)現(xiàn)數(shù)據(jù)庫操作接口
DynamicCache.DataLoader<String, User> loader = key -> 
    jdbcTemplate.queryForObject("SELECT * FROM users WHERE id=?", User.class, key);

DynamicCache.DataSynchronizer<String, User> synchronizer = new DynamicCache.DataSynchronizer<>() {
    @Override
    public void saveToDatabase(String key, User value) {
        jdbcTemplate.update("INSERT OR REPLACE INTO users (id, name) VALUES (?, ?)", 
                           key, value.getName());
    }

    @Override
    public void deleteFromDatabase(String key) {
        jdbcTemplate.update("DELETE FROM users WHERE id=?", key);
    }
};

// 2. 創(chuàng)建緩存實(shí)例
DynamicCache<String, User> userCache = new DynamicCache<>(loader, synchronizer);

// 3. 使用緩存
// 自動(dòng)加載（緩存未命中時(shí)從DB加載）
User user = userCache.get("user123");  

// 添加/更新（同步到DB）
userCache.put("user456", new User("Alice"));

// 刪除（同步刪除DB數(shù)據(jù)）
userCache.delete("user789");

.scheduler(Scheduler.systemScheduler())