easyfk-cache-caffeine 本地缓存

dependencies {
    implementation 'com.mcst:cache-caffeine'
}

easyfk:
  config:
    cache:
      caffeine:
        create-spring-cache-manager: true
        default-cache-name: default
        time-to-live: 10m
        maximum-size: 5000
        caches:
          - cache-name: userCache
            time-to-live: 30m
            maximum-size: 2000
          - cache-name: configCache
            time-to-live: 1h
            maximum-size: 500

@Service
public class MyService {

    @Resource
    private LocalCacheManager localCacheManager;
}

// 创建一个写后10分钟过期、最多缓存1000条的缓存
Cache<String, User> userCache = localCacheManager.getOrCreateCache("userCache", Duration.ofMinutes(10), 1000);

// 仅指定最大数量（不过期）
Cache<String, Config> configCache = localCacheManager.getOrCreateCache("configCache", 5000);

// 指定过期类型：0=写后过期，1=读后过期
Cache<String, Token> tokenCache = localCacheManager.getOrCreateCache("tokenCache", Duration.ofHours(1), 1, 2000);

// 写入
localCacheManager.put("userCache", "user:1001", userObj);

// 读取
User user = localCacheManager.get("userCache", "user:1001");

// 读取（缓存未命中时自动加载）
User user = localCacheManager.get("userCache", "user:1001", key -> userService.findById(key));

// 删除
localCacheManager.evict("userCache", "user:1001");

// 清空整个缓存
localCacheManager.clear("userCache");

// 批量读取
Set<String> keys = Set.of("user:1001", "user:1002", "user:1003");
Map<String, User> users = localCacheManager.getAll("userCache", keys);

// 批量写入
Map<String, Object> entries = Map.of("user:1001", user1, "user:1002", user2);
localCacheManager.putAll("userCache", entries);

// 批量删除
localCacheManager.evictAll("userCache", keys);

// 获取缓存预估大小
long size = localCacheManager.estimatedSize("userCache");

// 手动触发缓存清理（触发过期条目回收）
localCacheManager.cleanUp("userCache");

// 删除已管理的缓存实例
localCacheManager.removeCache("userCache");

// 创建自动加载缓存
LoadingCache<String, User> cache = localCacheManager.getOrCreateLoadingCache(
    "userCache",
    Duration.ofMinutes(10),
    1000,
    key -> userService.findById(key)  // CacheLoader
);

// 获取值（缓存未命中时自动调用 loader）
User user = localCacheManager.getFromLoadingCache("userCache", "user:1001");

// 批量获取（自动加载缺失的键）
Map<String, User> users = localCacheManager.getAllFromLoadingCache("userCache", Set.of("user:1001", "user:1002"));

// 手动刷新某个键
localCacheManager.refreshLoadingCache("userCache", "user:1001");

// 写后10分钟过期，写后5分钟触发异步刷新
LoadingCache<String, Config> cache = localCacheManager.getOrCreateLoadingCache(
    "configCache",
    Duration.ofMinutes(10),    // 过期时间
    Duration.ofMinutes(5),     // 刷新时间
    5000,
    key -> configService.load(key)
);

LoadingCache<String, User> cache = localCacheManager.getOrCreateLoadingCacheWithStats(
    "userCache",
    Duration.ofMinutes(10),
    1000,
    key -> userService.findById(key)
);

// 获取统计信息
CacheStats stats = cache.stats();
// stats.hitRate(), stats.missRate(), stats.loadCount() 等

// 创建异步缓存
AsyncCache<String, User> asyncCache = localCacheManager.getOrCreateAsyncCache(
    "asyncUserCache",
    Duration.ofMinutes(10),
    1000
);

// 异步获取（未命中时通过函数加载）
CompletableFuture<User> future = localCacheManager.getFromAsyncCache(
    "asyncUserCache",
    "user:1001",
    key -> userService.findById(key)
);

// 异步放入
localCacheManager.putToAsyncCache(
    "asyncUserCache",
    "user:1001",
    CompletableFuture.supplyAsync(() -> userService.findById("user:1001"))
);

// 使用同步 loader（Caffeine 自动包装为异步执行）
AsyncLoadingCache<String, User> cache = localCacheManager.getOrCreateAsyncLoadingCache(
    "asyncUserCache",
    Duration.ofMinutes(10),
    1000,
    (CacheLoader<String, User>) key -> userService.findById(key)
);

// 使用异步 loader
AsyncLoadingCache<String, User> cache = localCacheManager.getOrCreateAsyncLoadingCache(
    "asyncUserCache",
    Duration.ofMinutes(10),
    1000,
    (AsyncCacheLoader<String, User>) (key, executor) ->
        CompletableFuture.supplyAsync(() -> userService.findById(key), executor)
);

// 异步获取
CompletableFuture<User> future = localCacheManager.getFromAsyncLoadingCache("asyncUserCache", "user:1001");

// 异步批量获取
CompletableFuture<Map<String, User>> futures = localCacheManager.getAllFromAsyncLoadingCache(
    "asyncUserCache",
    Set.of("user:1001", "user:1002")
);

// 弱引用值缓存 — 值无强引用时可被 GC 回收
Cache<String, User> weakCache = localCacheManager.getOrCreateWeakValuesCache("weakCache", Duration.ofMinutes(10), 1000);

// 软引用值缓存 — 内存不足时值可被 GC 回收
Cache<String, User> softCache = localCacheManager.getOrCreateSoftValuesCache("softCache", Duration.ofMinutes(10), 1000);

// 弱引用键缓存 — 键无强引用时可被 GC 回收
Cache<String, User> weakKeyCache = localCacheManager.getOrCreateWeakKeysCache("weakKeyCache", Duration.ofMinutes(10), 1000);

// 带统计功能的缓存
Cache<String, User> statsCache = localCacheManager.getOrCreateCacheWithStats("statsCache", Duration.ofMinutes(10), 1000);

@Service
public class UserService {

    @Cacheable(value = "userCache", key = "#id")
    public User findById(String id) {
        return userRepository.findById(id);
    }

    @CachePut(value = "userCache", key = "#user.id")
    public User update(User user) {
        return userRepository.save(user);
    }

    @CacheEvict(value = "userCache", key = "#id")
    public void delete(String id) {
        userRepository.deleteById(id);
    }

    @CacheEvict(value = "userCache", allEntries = true)
    public void clearAll() {
        // 清空 userCache 所有条目
    }
}

com.mcst.easyfk.cache.caffeine
├── config
│   ├── CaffeineCacheConfig.java        # Spring Cache 管理器配置（条件激活）
│   ├── CaffeineDefinedInfo.java        # 缓存定义信息实体
│   └── CaffeineSimpleConfig.java       # LocalCacheManager 自动配置
├── manager
│   └── LocalCacheManager.java          # 核心缓存管理器
└── properties
    └── CaffeineCacheProperties.java    # 配置属性绑定类