Redis 缓存：命中之外，还要设计失效

import java.util.*;
import java.util.function.Function;
public class Main {
    record Entry(Optional<String> value,long expires) {}
    static class Cache {
        final int capacity;
        final Function<String,Optional<String>> origin;
        final LinkedHashMap<String,Entry> entries=new LinkedHashMap<>(16,0.75f,true);
        long last=-1;
        Cache(int capacity,Function<String,Optional<String>> origin) {
            if (capacity<1) throw new IllegalArgumentException("capacity");
            this.capacity=capacity; this.origin=origin;
        }
        Optional<String> get(String key,long now) {
            if (now<0||now<last) throw new IllegalArgumentException("clock");
            last=now;
            Entry cached=entries.get(key);
            if (cached!=null&&now<cached.expires()) return cached.value();
            entries.remove(key);
            // 来源异常直接传播，不把失败翻译成不存在。
            Optional<String> value=Objects.requireNonNull(origin.apply(key));
            long ttl=value.isPresent()?10:2;
            long expires=Math.addExact(now,ttl);
            // 成功读取后才回填，负缓存有独立较短有效期。
            entries.put(key,new Entry(value,expires));
            if (entries.size()>capacity) {
                Iterator<String> oldest=entries.keySet().iterator();
                oldest.next(); oldest.remove(); // 淘汰最久未使用项。
            }
            return value;
        }
        void invalidate(String key) { entries.remove(key); }
    }
    static void eq(Object expected,Object actual) {
        if (!Objects.equals(expected,actual)) throw new AssertionError(actual);
    }
    public static void main(String[] args) {
        int[] loads={0};
        Cache cache=new Cache(2,key->{loads[0]++;return Optional.of(key);});
        eq(Optional.of("a"),cache.get("a",0));
        cache.get("a",1); eq(1,loads[0]);
        cache.get("a",10); eq(2,loads[0]);
        cache.get("b",10); cache.get("a",10); cache.get("c",10);
        cache.get("b",10); eq(5,loads[0]);
        int[] misses={0};
        Cache negative=new Cache(2,key->{misses[0]++;return Optional.empty();});
        negative.get("x",0); negative.get("x",1); eq(1,misses[0]);
        negative.get("x",2); eq(2,misses[0]);
        int[] failures={0};
        Cache broken=new Cache(1,key->{failures[0]++;throw new IllegalStateException("database");});
        for (int i=0;i<2;i++) {
            try { broken.get("x",i); throw new AssertionError("expected failure"); }
            catch (IllegalStateException expected) {}
        }
        eq(2,failures[0]); eq(0,broken.entries.size());
        cache.invalidate("b"); cache.get("b",11); eq(6,loads[0]);
        System.out.println("PASS 9 cache-aside assertions");
    }
}