Java 本地缓存入门指南

一、缓存基础认知

什么是缓存？
缓存是存储在内存中的临时数据，用于加速数据访问。将用户频繁查询的数据存放在缓存中，避免每次都去数据库查询，从而提高效率，解决高并发系统的性能问题。

为什么使用缓存？
减少与数据库的交互，降低系统开销，提升效率。
什么样的数据适合缓存？
经常查询且不经常变动的数据。

二、缓存类型：本地缓存与分布式缓存

对于 Java 开发者而言，通常会首先想到 Redis 这样的分布式缓存。它将应用进程和缓存进程分开，使用 RPC 或 HTTP 进行通信。优点是支持大数据量存储，缺点是存在网络传输的性能损耗。
与之相对的是本地缓存，它与应用进程在同一进程内，读写操作速度更快，但受限于 JVM 内存，不适合存储大数据。

• 分布式缓存，例如Redis：
  优点：存储容量更大、可靠性更好、可以在集群间共享
  缺点：访问缓存有网络开销
  场景：缓存数据量较大、可靠性要求较高、需要在集群间共享

• 进程本地缓存，例如HashMap、GuavaCache：
  优点：读取本地内存，没有网络开销，速度更快
  缺点：存储容量有限、可靠性较低、无法共享
  场景：性能要求较高，缓存数据量较小
  注意：JDK内置的Map可作为缓存的一种实现方式，然而严格来说他不算缓存的范畴。原因如下：一是其存储的数据不能主动过期；而是无任何缓存淘汰策略。

三、常用本地缓存技术

本地缓存需要考虑容量限制、过期策略、淘汰策略等。常用的本地缓存方案包括：

• Caffeine
• EhCache
• Guava Cache

1.Guava Cache

Guava 是 Google 开源的一款 Java 核心增强库，包含集合、并发原语、缓存等功能。它支持：

• 最大容量限制
• 两种过期策略（插入时间和访问时间）
• 简单的统计功能
• 基于 LRU 算法

引入依赖

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>18.0</version>
</dependency>

示例代码

public class GuavaCacheTest {
    public static void main(String[] args) throws ExecutionException {
        Cache<Object, Object> loadingCache = CacheBuilder.newBuilder()
                .initialCapacity(5)
                .maximumSize(10)
                .expireAfterWrite(17, TimeUnit.SECONDS)
                .build();
        String key = "key";
        loadingCache.put("key", "bv");

        // 获取value的值，如果key不存在，获取value后再返回
        String val = (String)loadingCache.get(key, () -> getValueFromDB(key));
        System.out.println("失效前的值："+val);
        loadingCache.invalidate(key);
        System.out.println("失效后的值："+(String)loadingCache.get(key, () -> getValueFromDB(key)));
    }
}

输出示例：

失效前的值：bv
失效后的值：av

2. Caffeine

• Caffeine 是基于 Java 8 的高性能缓存库，Spring 5 后成为默认缓存组件。
• GitHub地址：https://github.com/ben-manes/caffeine

引入依赖

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

示例代码

public class CaffeinTest {

    public static void main(String[] args) throws Exception {
        Cache<String, String> loadingCache = Caffeine.newBuilder()
                .initialCapacity(5) //cache的初始容量
                .maximumSize(10) //cache最大缓存数，超过缓存数之后，最先写入的会被淘汰
                .expireAfterWrite(3, SECONDS) //设置写缓存后n秒钟过期，从最后一次写入开始计时
                .build();

        loadingCache.put("bf", "fcc");// 往缓存写数据


        for (int i = 1; i < 5; i++) {
            // 获取value的值，如果key不存在，获取value后再返回
            String value = loadingCache.get("bf", CaffeinTest::getValueFromDB);
            System.out.println("第"+i+"次获得数据："+value);
            Thread.sleep(1000);
        }
        // 删除key
        loadingCache.invalidate("bf");
        System.out.println("======");
        String value = loadingCache.get("bf", CaffeinTest::getValueFromDB);
        System.out.println("获取默认值： "+value);
    }

    private static String getValueFromDB(String key) {
        return "pbj";
    }
}

输出值：

第1次获得数据：fcc
第2次获得数据：fcc
第3次获得数据：fcc
第4次获得数据：pbj
======
获取默认值： pbj

注意事项
在默认情况下，当一个缓存元素过期的时候，Caffeine不会自动立即将其清理和驱逐。而是在一次读或写操作后，或者在空闲时间完成对失效数据的驱逐。

商城代码示例： 先查缓存再查数据库

@Configuration
public class CaffineConfig {
    @Bean
    public Cache<Long, Item> itemCache(){
        return Caffeine.newBuilder().initialCapacity(100).maximumSize(10000).build();
    }

    @Bean
    public Cache<Long, ItemStock> stockCache(){
        return Caffeine.newBuilder().initialCapacity(100).maximumSize(10000).build();
    }
}

========Controller代码=====
@Autowired
private Cache<Long, Item> itemCache;
@Autowired
private Cache<Long, ItemStock> stockCache;

@GetMapping("/{id}")
public Item findById(@PathVariable("id") Long id){
    //优先根据id查缓存，查不到才会在数据库里查
    return itemCache.get(id, key -> itemService.query()
            .ne("status", 3).eq("id", id)
            .one());
}

@GetMapping("/stock/{id}")
public ItemStock findStockById(@PathVariable("id") Long id){
    return stockCache.get(id, key -> stockService.getById(id));
}

3. EhCache

EhCache 是一个纯 Java 的进程内缓存框架，提供内存和磁盘两级缓存，支持多种缓存策略。
1. 引入依赖

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

2. 配置 Ehcache
在 application.yml 或 application.properties 配置文件中添加 Ehcache 的配置信息，例如：

spring:
  ehcache:
    config: classpath:ehcache.xml

3. src/main/resources 目录下添加 ehcache.xml 配置

<?xml version="1.0" encoding="UTF-8"?>
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns="http://www.ehcache.org/v3"
        xsi:schemaLocation="http://www.ehcache.org/v3 http://www.ehcache.org/schema/ehcache-core-3.0.xsd">

  <cache alias="myCache">
	  <key-type>java.lang.String</key-type>
	  <value-type>java.lang.String</value-type>
	  <heap>10</heap> <!-- 最多存储 10 个缓存项到堆中 -->
	  <offheap>1MB</offheap> <!-- 最多存储 1MB 缓存项到堆外内存中 -->
	  <diskPersistent>true</diskPersistent> <!-- 开启磁盘持久化，即使程序重启后，缓存仍然有效 -->
	  <diskSpoolBufferSizeMB>30</diskSpoolBufferSizeMB> <!-- 磁盘缓存区大小，缓存数据先以临时文件的形式写入磁盘缓存区，待达到一定阈值后再写入磁盘 -->
	  <diskExpiryThreadIntervalSeconds>120</diskExpiryThreadIntervalSeconds> <!-- 磁盘数据过期检测间隔时间，单位为秒 -->
	  <maxEntriesLocalDisk>1000</maxEntriesLocalDisk> <!-- 磁盘缓存最大存储数量 -->
</cache>


</config>

示例代码

public class EhCacheTest {
    public static void main(String[] args) throws Exception {
        CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder()
                .withCache("encacheInstance", CacheConfigurationBuilder
                        .newCacheConfigurationBuilder(String.class, String.class, ResourcePoolsBuilder.heap(20)))
                .build(true);

        Cache<String, String> myCache = cacheManager.getCache("encacheInstance", String.class, String.class);
        myCache.put("key", "v");
        String value = myCache.get("key");
        cacheManager.removeCache("myCache");
        cacheManager.close();
    }
}

四、总结

• 易用性：Guava Cache、Caffeine 和 EhCache 都有成熟的接入方案。
• 功能性：Guava Cache 和 Caffeine 功能类似，EhCache 功能更丰富。
• 性能比较：Caffeine 性能最佳，其次是 Guava Cache，EhCache 性能较差。
  推荐在本地缓存中使用 Caffeine，结合 Redis 或 Memcache 构建多级缓存体系，以保证性能和可靠性。