缓存失效策略在 Java 中如何实现

在Java中，缓存失效策略可以通过多种方式实现，以下是一些常见的策略：

1. 基于时间的失效（Time-based expiration）：

   在这种策略中，为缓存中的每个条目设置一个过期时间。当条目过期后，下一次访问该条目时，将触发重新加载或更新缓存。可以使用java.util.concurrent.TimeUnit来设置过期时间。

   示例代码：

   public class TimeBasedCache<K, V> {
       private final Map<K, CacheEntry<V>> cache = new ConcurrentHashMap<>();
       private final long expirationTime;
   
       public TimeBasedCache(long expirationTime, TimeUnit timeUnit) {
           this.expirationTime = System.currentTimeMillis() + timeUnit.toMillis(expirationTime);
       }
   
       public V get(K key) {
           CacheEntry<V> entry = cache.get(key);
           if (entry == null || entry.isExpired()) {
               return loadFromSource(key);
           }
           return entry.getValue();
       }
   
       private V loadFromSource(K key) {
           // 从数据源加载数据的逻辑
           return null;
       }
   
       public void put(K key, V value) {
           cache.put(key, new CacheEntry<>(value, expirationTime));
       }
   
       private static class CacheEntry<V> {
           private final V value;
           private final long expirationTime;
   
           public CacheEntry(V value, long expirationTime) {
               this.value = value;
               this.expirationTime = expirationTime;
           }
   
           public boolean isExpired() {
               return System.currentTimeMillis() > expirationTime;
           }
       }
   }
   

2. 基于大小的失效（Size-based expiration）：

   在这种策略中，当缓存达到其最大容量时，将按照一定的策略移除最旧的条目。可以使用LinkedHashMap来实现基于大小的失效。

   示例代码：

   public class SizeBasedCache<K, V> extends LinkedHashMap<K, V> {
       private final int maxSize;
   
       public SizeBasedCache(int maxSize) {
           super(maxSize, 0.75f, true);
           this.maxSize = maxSize;
       }
   
       @Override
       protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
           return size() > maxSize;
       }
   }
   

3. 基于访问频率的失效（Frequency-based expiration）：

   在这种策略中，根据缓存条目的访问频率来决定何时移除该条目。可以使用HashMap和LinkedHashMap的组合来实现基于访问频率的失效。

   示例代码：

   public class FrequencyBasedCache<K, V> {
       private final Map<K, CacheEntry<V>> cache = new ConcurrentHashMap<>();
       private final int maxFrequency;
   
       public FrequencyBasedCache(int maxFrequency) {
           this.maxFrequency = maxFrequency;
       }
   
       public V get(K key) {
           CacheEntry<V> entry = cache.get(key);
           if (entry == null || entry.getFrequency() >= maxFrequency) {
               return loadFromSource(key);
           }
           entry.incrementFrequency();
           return entry.getValue();
       }
   
       private V loadFromSource(K key) {
           // 从数据源加载数据的逻辑
           return null;
       }
   
       public void put(K key, V value) {
           cache.put(key, new CacheEntry<>(value, maxFrequency));
       }
   
       private static class CacheEntry<V> {
           private final V value;
           private int frequency;
           private final int maxFrequency;
   
           public CacheEntry(V value, int maxFrequency) {
               this.value = value;
               this.maxFrequency = maxFrequency;
               this.frequency = 1;
           }
   
           public int getFrequency() {
               return frequency;
           }
   
           public void incrementFrequency() {
               frequency++;
           }
       }
   }
   

这些策略可以单独使用，也可以组合使用以满足特定应用程序的需求。在实际应用中，可以根据具体情况选择合适的缓存失效策略。