Java实现本地缓存的四种方法实现与对比

package com.taiyuan.javademoone.cachedemo;
 
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
 
/**
 * 定义一个基于LinkedHashMap实现的线程安全的LRU缓存类
 */
public class LRUCache extends LinkedHashMap<Object, Object> {  // 明确泛型类型为<Object, Object>，提高代码可读性
    /**
     * 可重入读写锁，用于保证多线程环境下对缓存的并发读写操作的安全性
     */
    private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private Lock readLock = readWriteLock.readLock();   // 读锁，用于并发读取时共享访问
    private Lock writeLock = readWriteLock.writeLock(); // 写锁，用于写入或修改时独占访问
 
    /**
     * 缓存的最大容量限制，超过此容量将移除最久未使用的条目
     */
    private int maxSize;
 
    /**
     * 构造函数，初始化LRU缓存并设置最大容量
     *
     * @param maxSize 缓存允许存储的最大条目数
     */
    public LRUCache(int maxSize) {
        // 调用父类LinkedHashMap的构造方法：
        // 参数1：初始容量为maxSize + 1，避免频繁扩容
        // 参数2：负载因子为1.0f，表示哈希表填满到100%时才扩容
        // 参数3：accessOrder为true，表示按照访问顺序排序，实现LRU策略
        super(maxSize + 1, 1.0f, true);
        this.maxSize = maxSize;
    }
 
    /**
     * 重写get方法，获取指定key对应的value，使用读锁保证线程安全
     *
     * @param key 要查找的键
     * @return 对应的值，如果不存在则返回null
     */
    @Override
    public Object get(Object key) {
        readLock.lock();      // 加读锁，允许多个线程同时读
        try {
            return super.get(key); // 调用父类的get方法
        } finally {
            readLock.unlock(); // 确保读锁最终被释放
        }
    }
 
    /**
     * 重写put方法，向缓存中添加或更新键值对，使用写锁保证线程安全
     *
     * @param key   要插入或更新的键
     * @param value 要插入或更新的值
     * @return 之前与key关联的值，如果没有则返回null
     */
    @Override
    public Object put(Object key, Object value) {
        writeLock.lock();     // 加写锁，确保同一时间只有一个线程可以写
        try {
            return super.put(key, value); // 调用父类的put方法
        } finally {
            writeLock.unlock(); // 确保写锁最终被释放
        }
    }
 
    /**
     * 重写removeEldestEntry方法，当缓存大小超过maxSize时，移除最久未使用的条目
     *
     * @param eldest 最久未访问的键值对Entry
     * @return 如果当前缓存大小超过最大容量，则返回true，触发删除最老的条目；否则返回false
     */
    @Override
    protected boolean removeEldestEntry(Map.Entry eldest) {
        return this.size() > maxSize; // 判断当前缓存大小是否超出限制
    }
 
 
 
    // 测试主方法
    public static void main(String[] args) {
        LRUCache cache = new LRUCache(3);
        cache.put("1", "one");
        cache.put("2", "two");
        cache.put("3", "three");
        System.out.println(cache); // 输出：{1=one, 2=two, 3=three}
    }
}

<!-- https://mvnrepository.com/artifact/com.google.guava/guava -->
<dependency>
  <groupId>com.google.guava</groupId>
  <artifactId>guava</artifactId>
  <version>33.4.8-jre</version>
</dependency>

package com.helloworld.demo;
 
import com.google.common.cache.*;
 
import java.util.concurrent.TimeUnit;
 
public class GuavaCacheExample {
    public static void main(String[] args) {
        // 创建一个Guava的LoadingCache实例，支持自动加载缓存项
        LoadingCache<String, String> cache = CacheBuilder.newBuilder()
                .maximumSize(100)                     // 设置缓存最大容量为100个条目
                .expireAfterWrite(10, TimeUnit.MINUTES) // 设置缓存项在写入10分钟后自动过期
                .recordStats()                         // 开启缓存统计功能，可以获取命中率等信息
                .build(new CacheLoader<String, String>() { // 定义缓存未命中时的加载逻辑
                    @Override
                    public String load(String key) throws Exception {
                        // 当根据key获取不到缓存值时，调用此方法从数据源（如数据库）加载数据
                        return fetchDataFromDatabase(key);
                    }
                });
 
        try {
            // 第一次获取key为"user:1001"的值，由于缓存中没有，会触发load方法从数据库加载
            System.out.println("第一次获取(从数据库加载): " + cache.get("user:1001"));
            // 第二次获取相同的key，此时缓存中已有该值，直接从缓存返回，不会再次加载
            System.out.println("第二次获取(从缓存获取): " + cache.get("user:1001"));
 
            // 手动向缓存中放入一个键值对，绕过自动加载逻辑
            cache.put("user:1002", "Manual Data");
            // 获取手动放入的缓存值
            System.out.println("手动放入的数据: " + cache.get("user:1002"));
 
            // 打印缓存的统计信息，如命中率、加载次数等
            System.out.println("\n缓存统计:");
            System.out.println(cache.stats());
 
            // 手动移除指定key的缓存项
            cache.invalidate("user:1001");
            // 尝试获取已被移除的缓存项，返回null表示不存在
            System.out.println("\n移除后获取: " + cache.getIfPresent("user:1001"));
 
        } catch (Exception e) {
            e.printStackTrace(); // 捕获并打印异常信息
        }
    }
 
    // 模拟从数据库中根据key获取数据的逻辑
    private static String fetchDataFromDatabase(String key) {
        // 打印当前正在加载的key，用于观察加载行为
        System.out.println("正在从数据库加载数据: " + key);
        try {
            Thread.sleep(500); // 模拟数据库查询的延迟，增加真实感
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt(); // 恢复中断状态
        }
        // 返回模拟的数据库查询结果
        return "Data for " + key;
    }
}

<dependency>
  <groupId>com.github.ben-manes.caffeine</groupId>
  <artifactId>caffeine</artifactId>
  <version>2.9.3</version>
</dependency>

package com.helloworld.demo;
 
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
 
import java.util.concurrent.TimeUnit;
 
public class CaffeineCacheTest {
    public static void main(String[] args) throws Exception {
        // 创建一个 Caffeine 缓存实例（注意：原注释写的是 Guava Cache，实际使用的是 Caffeine）
        Cache<String, String> loadingCache = Caffeine.newBuilder()
                .initialCapacity(5) // 设置初始缓存容量为 5 个条目
                .maximumSize(10)    // 设置缓存最大容量为 10 个条目，超过时将按照策略淘汰
                .expireAfterWrite(17, TimeUnit.SECONDS) // 写入后 17 秒过期
                .expireAfterAccess(17, TimeUnit.SECONDS) // 最后一次访问后 17 秒过期
                .build(); // 构建缓存实例
 
        String key = "key"; // 定义缓存的键
        loadingCache.put(key, "这是测试方法"); // 手动将键值对放入缓存
        // 从缓存中获取指定键的值
        String value = loadingCache.getIfPresent(key);
        System.out.println(" 从缓存中获取指定键（key）的值：" + value); // 输出：这是测试方法
 
        // 将指定的键从缓存中移除（使其失效）
        loadingCache.invalidate(key);
        value = loadingCache.getIfPresent(key);
        System.out.println(" 从缓存中获取指定键（key）的值：" + value); // 输出：null
    }
 
}

<dependency>
  <groupId>org.ehcache</groupId>
  <artifactId>ehcache</artifactId>
  <version>3.10.8</version>
</dependency>

package com.helloworld.demo;
 
import org.ehcache.Cache;
import org.ehcache.CacheManager;
import org.ehcache.config.builders.CacheConfigurationBuilder;
import org.ehcache.config.builders.CacheManagerBuilder;
import org.ehcache.config.builders.ResourcePoolsBuilder;
import org.ehcache.config.units.MemoryUnit;
 
/**
 * Ehcache 基础使用示例类
 */
public class EhcacheBasicExample {
    public static void main(String[] args) {
        // 1. 创建缓存管理器（CacheManager），它是管理所有缓存的核心对象
        CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder().build();
        // 初始化缓存管理器，使其可以开始工作
        cacheManager.init();
 
        // 2. 创建一个缓存配置，定义缓存的键值类型和存储策略
        CacheConfigurationBuilder<String, String> config = CacheConfigurationBuilder
        .newCacheConfigurationBuilder(
            String.class,         // 缓存键的类型为 String
            String.class,         // 缓存值的类型为 String
            ResourcePoolsBuilder.heap(100) // 配置堆内内存缓存最多存储 100 个条目
        );
 
        // 3. 根据配置创建一个名为 "myCache" 的缓存实例
        Cache<String, String> myCache = cacheManager.createCache("myCache", config);
 
        // 4. 使用缓存：存储和读取数据
        myCache.put("key1", "value1");          // 往缓存中放入一个键值对
        String value = myCache.get("key1");     // 从缓存中根据 key 获取对应的 value
        System.out.println("获取的值: " + value); // 打印获取到的缓存值
 
        // 5. 使用完缓存后，关闭缓存管理器以释放资源
        cacheManager.close();
    }
}