具有复杂条件驱逐的缓存

Question

我试图使用咖啡因和spring boot starter缓存实现以下缓存逻辑：

1. 如果过期时间已经过去，条件（需要计算和I/O）被评估为TRUE，然后强制获取数据并更新缓存。
2. 如果过期时间已经过去，条件（需要计算和I/O）被计算为FALSE，那么不要使缓存数据无效，并从缓存中检索值。
3. 如果过期时间未过，则从缓存中检索该值。

我按照这个指南工作：https://www.baeldung.com/spring-boot-caffeine-cache

我尝试了所有类型的方法使用@CachePUT，@CacheEvket和@Cacheable对对象的getter方法我；m缓存，但核心问题是我需要条件驱逐一个过期时间和另一个逻辑，但是这些注释不能控制是否驱逐...也许这可以使用Scheduler来完成？

Answer 1

看来你不是用咖啡因作为缓存系统。

在这种情况下，使用自定义类并在简单映射中保存数据会更好，因为它为您提供了更大的灵活性。

这是一副骷髅

public class SpecialCache {
    private Map<String, SpecialCache.Entry> map = new HashMap<>();

    private boolean specialCondition(String key) {
        ...
    }

    private Object fetch(String key) {
       ...
    }


    public Object get(String key) {
        SpecialCache.Entry entry = map.get(key);
        if (entry.getExpiringEpoch() > System.currentTimeMillis()) {
            if (specialCondition(key)) {
                Object data = fetch(key);
                entry.setExpiringEpoch(...);
                entry.setData(data);
                return data;
            } else {
                return entry.getData();
            } 
        } else {
            return entry.getData();
        }
    }

    @Data
    public static class Entry {
        private long expiringEpoch;
        private Object data;
    }
}

在这个例子中，我在缓存中添加了特殊条件和读取方法。您还可以将方法作为lambda函数传递给get方法，以获得更大的灵活性。

代码必须以完成，例如，您需要添加：

• 检查缓存中不存在的键
• 填充缓存的方法（一个放？）

Answer 2

我想你正在寻找刷新后写并覆盖CacheLoader.reload（K， V）。下面是解释细节的帖子：https://github.com/ben-manes/caffeine/wiki/Refresh

对您的案例的实现类似于：

java prettyprint-override">@Log4j2
@Configuration
public class CacheConfig {

    @Bean
    public Cache<String,Item> caffeineConfig() {
        return Caffeine.newBuilder()
            .refreshAfterWrite(10, TimeUnit.SECONDS)
            .build(new ConditionalCacheLoader<>(this::shouldReload, this::load));
    }

    private Item load(String key){
        //load the item
        return null;
    }

    private boolean shouldReload(Item oldValue){
        //your condition logic here
        return true;
    }


    private static class Item{
         // the item value can contain any data
    }

    private static class ConditionalCacheLoader<K,V> implements CacheLoader<K,V>{
        private final Predicate<V> shouldReload;

        private final Function<K,V> load;

        protected ConditionalCacheLoader(Predicate<V> shouldReload, Function<K, V> load) {
            this.shouldReload = shouldReload;
            this.load = load;
        }

        @Override
        public V load(K key) throws Exception{
            return load.apply(key);
        }

        @Override
        public V reload(K key, V oldValue) throws Exception {
            if (shouldReload.test(oldValue)){
                return load(key);
            }else {
                return oldValue;
            }
        }
    }
}