Java分布式缓存VS本地缓存用法及说明

import java.util.concurrent.ConcurrentHashMap;

public class SimpleCache<K, V> {
    private final ConcurrentHashMap<K, V> cache = new ConcurrentHashMap<>();

    public V get(K key) {
        return cache.get(key);
    }

    public void put(K key, V value) {
        cache.put(key, value);
    }

    public void remove(K key) {
        cache.remove(key);
    }
}

import com.google.common.cache.CacheBuilder;
import com.google.common.cache.Cache;

public class GuavaCacheExample {
    public static void main(String[] args) {
        // 创建缓存：最大容量100，写入后1分钟过期
        Cache<String, String> cache = CacheBuilder.newBuilder()
            .maximumSize(100)
            .expireAfterWrite(1, TimeUnit.MINUTES)
            .build();

        cache.put("key1", "value1");
        String value = cache.getIfPresent("key1"); // 获取缓存
        System.out.println("Value: " + value);
    }
}

import com.github.benmanes.caffeine.cache.Cache;        // Caffeine缓存接口
import com.github.benmanes.caffeine.cache.Caffeine;     // Caffeine缓存构建器
import java.util.concurrent.TimeUnit;                  // 时间单位工具类

public class CaffeineDemo {

    // 初始化Caffeine缓存实例
    // 1. 最大缓存条目数：1000条（超过后自动淘汰旧数据）
    // 2. 数据写入后10分钟过期（自动失效策略）
    private static final Cache<String, Product> cache = Caffeine.newBuilder()
        .maximumSize(1000)
        .expireAfterWrite(10, TimeUnit.MINUTES)
        .build();

    /**
     * 获取商品信息方法
     * @param productId 商品ID
     * @return Product 商品对象
     */
    public Product getProduct(String productId) {
        // Caffeine缓存核心API：get(key, mappingFunction)
        // 1. 如果缓存命中，直接返回缓存值
        // 2. 如果缓存未命中，执行mappingFunction加载数据到缓存
        // 3. mappingFunction参数使用Lambda表达式简化代码
        return cache.get(productId, id -> fetchProductFromDB(id));
    }

    /**
     * 模拟从数据库加载数据的方法
     * @param id 数据标识符
     * @return 数据对象
     */
    private Product fetchProductFromDB(String id) {
        // 实际开发中这里会调用数据库查询接口
        // 当前示例返回模拟数据
        return new Product(id, "Product-" + id);
    }
}

// Product类定义（示例）
class Product {
    private String id;
    private String name;

    public Product(String id, String name) {
        this.id = id;
        this.name = name;
    }

    // Getter方法省略
}

import org.ehcache.Cache;                               // Ehcache缓存接口
import org.ehcache.CacheManager;                        // 缓存管理器（管理多个缓存）
import org.ehcache.config.builders.CacheConfigurationBuilder;  // 缓存配置构建器
import org.ehcache.config.builders.ResourcePoolsBuilder;       // 资源池配置构建器
import org.ehcache.config.units.MemoryUnit;             // 内存单位枚举类（MB/GB）

public class EhcacheDemo {

    public static void main(String[] args) {
        // === 第一步：配置资源池 ===
        // ResourcePoolsBuilder用于定义缓存使用的存储资源类型和大小
        ResourcePoolsBuilder resourcePools = ResourcePoolsBuilder.newResourcePoolsBuilder()
            .heap(20, MemoryUnit.MB)       // 堆内缓存：20MB（速度最快，受JVM内存限制）
            .offheap(10, MemoryUnit.MB)    // 堆外缓存：10MB（突破JVM内存限制，速度次之）
            .disk(5, MemoryUnit.GB);       // 磁盘缓存：5GB（容量最大，速度最慢，适合冷数据）

        // === 第二步：创建缓存管理器和缓存实例 ===
        // CacheManagerBuilder构建缓存管理器，withCache()添加具体缓存配置
        // build(true) 表示立即构建（实际生产环境建议延迟初始化）
        CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder()
            .withCache("myCache", CacheConfigurationBuilder.newCacheConfigurationBuilder(
                String.class, String.class, resourcePools))  // 定义缓存名称和键值类型
            .build(true);

        // 从缓存管理器中获取具体缓存实例
        // 泛型参数指定键值类型为<String, String>
        Cache<String, String> cache = cacheManager.getCache("myCache", String.class, String.class);

        // === 第三步：缓存操作 ===
        // 存入数据：key1 -> value1
        cache.put("key1", "value1");

        // 获取数据：自动从堆内->堆外->磁盘按优先级查找
        System.out.println("Value: " + cache.get("key1"));  // 输出：Value: value1
    }
}

// 使用Redis缓存最新100条评论
String redisKey = "latest_comments";
jedis.lpush(redisKey, newComment); // 添加新评论到列表头部
jedis.ltrim(redisKey, 0, 99);      // 保留最近100条评论