Java缓存之Guava Cache & Caffeine

1 Java缓存主流框架介绍

1.1 Spring Cache

Redirecting...

https://docs.spring.io/spring-framework/docs/current/reference/html/integration.html#cache

1. 基于AOP与方法级注解实现自动缓存操作, 不需要手动进行缓存的写入与清除操作

2. 官方提供了多种开箱即用的缓存实现(EhCache / Redis / Caffeine / Map 等), 也支持自定义缓存实现

1.2 Guava Cache

CachesExplained

Google core libraries for Java. Contribute to google/guava development by creating an account on GitHub.

https://github.com/google/guava/wiki/CachesExplained

1. 基于ConcurrentHashMap, 支持高并发下的线程安全, 性能也做了优化

2. 提供CacheBuilder, 简化缓存操作对象的创建, 支持设置自定义的CacheLoader用来加载数据至缓存

3. 使用软引用与弱引用机制, 保障GC安全

4. 支持key移除监听, 支持同步监听与异步监听, 在key移除后执行一些逻辑

5. 支持多个缓存清除策略: 存活时间 / 最大容量 / 主动清除 / 软弱引用

6. 支持获取指定缓存集合的命中率等指标

1.3 Caffeine

Home

A high performance caching library for Java. Contribute to ben-manes/caffeine development by creating an account on GitHub.

https://github.com/ben-manes/caffeine/wiki

1. 具备GuavaCache几乎所有特性, 并提供了适配器, 方便Guava用户迁移至Caffeine

2. 通过异步维护/异步通知/异步刷新等方式, 达到了极致的读写性能

3. 实现了JSR-107 JCache接口API

1.4 J2Cache

红薯/J2Cache

Java 两级缓存框架，可以让应用支持两级缓存框架 ehcache(Caffeine) + redis 。避免完全使用独立缓存系统所带来的网络IO开销问题

https://gitee.com/ld/J2Cache

1.5 EhCache

GitHub - ehcache/ehcache3: Ehcache 3.x line

Ehcache 3.x line . Contribute to ehcache/ehcache3 development by creating an account on GitHub.

https://github.com/ehcache/ehcache3

1. 实现了JSR107的规范, 并支持无缝集成 SpringCache/Hibernate/Tomcat等

2. 轻量级核心, 除slf4j外无其他依赖

3. 支持 堆内内存 / 堆外内存 / 磁盘 / 远程缓存服务 三层存储

4. 支持多种缓存模型: 独立缓存 / 分布式缓存 / 复制式缓存
1. 独立缓存: 每个应用实例在本地维护缓存, 意味着在其中一个实例中修改了缓存, 会导致与其他实例的缓存信息不一致
2. 分布式缓存: 每个应用实例本地维护少量热点缓存, 并有一个远程缓存服务端来管理更多的缓存信息, 本地缓存未命中时则请求远程服务获取缓存信息, 这解决了缓存空间的问题, 但也无法保证实例间的本地缓存一致性
3. 复制式缓存: 通过引入第三方事件通知机制(rmi/jgroup/jms等), 来同步各个实例间的本地缓存(包含内存/硬盘), 这意味着每个实例都需要维护一份完整的缓存数据在内存/硬盘中, 开销不小, 并且大数据量下的频繁变更也容易导致各实例间的数据不致性

1.6 JetCache

jetcache/introduce_CN.md at master · alibaba/jetcache

JetCache is a Java cache framework. Contribute to alibaba/jetcache development by creating an account on GitHub.

https://github.com/alibaba/jetcache/blob/master/introduce_CN.md

1. 提供统一的, 类似jsr-107风格的API访问Cache, 并可通过注解创建并配置Cache实例

2. 提供类似SpringCache风格的注解, 实现声明式的方法缓存, 并支持TTL和两级缓存

3. 支持缓存自动刷新与加载保护, 防止高并发下缓存未命中时打爆数据库

4. 支持缓存的统计指标

1.7 其他

2 JSR-107

2.1 什么是JSR-107？

2.2 JAVA缓存概念

• Java缓存的一些能力

• 值存储和引用存储

• 缓存和Map

2.2.1 Java缓存的一些能力

• 提供一些特殊的缓存能力。例如缓存JAVA对象

• 定义出通用的抽象类和工具。例如：spring的Cache和CacheManager这两个接口

• 简单易用

• 对业务的侵略性低

• 提供进程内和分布式的缓存实现

• 支持按值或者引用来缓存数据

• 支持注解来实现缓存功能

2.2.2 值存储和引用存储

2.2.3 缓存与Map的区别

• 通过key存储数据

• key唯一

• 使用可变对象作为key需要特别小心

• 比较相等可以重写equals和hash方法

• 缓存存储的key和values都不能为空

• 缓存可以过期

• 空间不足的时候，某些缓存有可能会被删除，当内存空间不足，可以运行某些策略释放一些旧的缓存，例如：LRU策略

• 实现CAS操作，需要实现equals方法

• 序列化keys和values

• 缓存可以选择不同的存储实体，以及不同的存储类型（值存储或者存储引用）

• 可以校验安全性，抛出异常

2.3 JCache引入使用

<!-- JCache -->
<dependency>
    <groupId>javax.cache</groupId>
    <artifactId>cache-api</artifactId>
    <version>1.1.0</version>
</dependency>
<dependency>
    <groupId>org.jsr107.ri</groupId>
    <artifactId>cache-ri-impl</artifactId>
    <version>1.1.1</version>
</dependency>

• CacheingProvider：管理多个CacheManager，制定建立，配置，请求机制

• CacheManager：管理多个Cache，制定建立，配置，请求机制，只有一个对应的CacheProvider

• Cache：对缓存操作，只有一个对应的CacheManager

• Cache.Entry：Cache接口的内部接口，真正的存储实体

• ExporyPolicy：控制缓存的过期时间。

public static void jCache() throws InterruptedException {
    // 创建缓存管理器
    CacheManager manager = Caching.getCachingProvider("org.jsr107.ri.spi.RICachingProvider").getCacheManager();
    // 创建一个配置管理器
    Configuration<Integer, String> configuration = new MutableConfiguration<Integer, String>()
            .setTypes(Integer.class, String.class)
            .setStoreByValue(false)
            .setExpiryPolicyFactory(CreatedExpiryPolicy.factoryOf(new Duration(TimeUnit.SECONDS, 5)));
    // 创建缓存对象
    Cache<Integer, String> cache = manager.createCache("JCache1", configuration);
    cache.put(1, "guazi1");
    System.out.println(cache.get(1));
    cache.put(2, "guazi2");
    Thread.sleep(6000);
    System.out.println(cache.get(2));
}

@EnableCaching
@Configuration
public class JCacheConfig {

    @Bean
    public JCacheCacheManager jCacheCacheManager() {
        // 创建缓存管理器
        CacheManager manager = Caching.getCachingProvider("org.jsr107.ri.spi.RICachingProvider").getCacheManager();
        // 创建一个配置管理器
        MutableConfiguration<Integer, String> configuration = new MutableConfiguration<Integer, String>()
                .setTypes(Integer.class, String.class)
                .setStoreByValue(false)
                .setExpiryPolicyFactory(CreatedExpiryPolicy.factoryOf(new Duration(TimeUnit.SECONDS, 5)));
        // 创建缓存对象
        Cache<Integer, String> cache = manager.createCache("JCache2", configuration);

        // jCache
        JCacheCacheManager jCache = new JCacheCacheManager();
        jCache.setCacheManager(manager);
        return jCache;
    }
}

@Service
public class JCacheServiceImpl {

    @CacheResult(cacheName = "JCache2")
    public String jCache2Query(@CacheKey Integer id) {
        System.out.println("jCache2Query, id: " + id);
        return "result: " + id;
    }

    @CachePut(cacheName = "JCache2")
    public String jCache2Update(@CacheKey Integer id, @CacheValue String newVal) {
        System.out.println("jCache2Update, id: " + id + ", newVal: " + newVal);
        return newVal;
    }

    @CacheRemove(cacheName = "JCache2")
    public void jCache2Delete(@CacheKey Integer id) {
        System.out.println("JCache2Delete, id: " + id);
    }
}

@RestController
public class JCacheController {

    @Resource
    private JCacheServiceImpl jCacheService;

    // http://127.0.0.1:8080/jcache?id=1
    @RequestMapping("/jcache")
    public Integer hello(@RequestParam Integer id) {
        jCacheService.jCache2Query(id);
        jCacheService.jCache2Update(id, "guazi1");
        jCacheService.jCache2Query(id);
        return id;
    }
}

3 Guava Cache

<!-- Guava -->
<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>32.1.3-jre</version>
</dependency>

3.1 支持缓存记录的过期设定

public static Cache<String, User> createUserCacheAfterWrite() {
    return CacheBuilder.newBuilder()
            .expireAfterWrite(30L, TimeUnit.MINUTES)
            .build();
}

public static Cache<String, User> createUserCacheAfterAccess() {
    return CacheBuilder.newBuilder()
            .expireAfterAccess(30L, TimeUnit.MINUTES)
            .build();
}

3.2 支持缓存容量限制与不同淘汰策略

public static Cache<String, User> createUserCacheMaximumSize() {
    return CacheBuilder.newBuilder()
            .maximumSize(10000L)
            .build();
}

public static Cache<String, User> createUserCacheMaximumWeight() {
    return CacheBuilder.newBuilder()
            .maximumWeight(10000L)
            .weigher((key, value) -> value.toString().length())
            .build();
}

3.3 支持集成数据源能力

public static User findUser(Cache<String, User> cache, String key) {
    try {
        return cache.get(key, () -> {
            System.out.println("缓存不存在...");
            return findUserFromDb(key);
        });
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}

public static LoadingCache<String, User> createUserCacheWithLoader() {
    return CacheBuilder.newBuilder()
            .build(new CacheLoader<String, User>() {
                @Override
                public User load(String key) {
                    System.out.println("缓存不存在...");
                    return findUserFromDb(key);
                }
            });
}

3.4 支持更新锁定能力

3.5 提供了缓存相关的一些监控统计

public static Cache<String, User> findUserCacheWithLoader() {
    LoadingCache<String, User> cache = CacheBuilder.newBuilder()
            .recordStats()
            .build(new CacheLoader<String, User>() {
                @Override
                public User load(String key) throws Exception {
                    System.out.println("缓存不存在...");
                    User user = findUserFromDb(key);
                    if (user == null) {
                        System.out.println("用户不存在");
                    }
                    return user;
                }
            });
    return cache;
}

Cache<String, User> userCacheWithLoader = findUserCacheWithLoader();
System.out.println(userCacheWithLoader.stats());

3.6 适用场景

• 数据读多写少且对一致性要求不高的场景

• 对性能要求极其严苛的场景

• 简单的本地数据缓存，作为HashMap/ConcurrentHashMap的替代品

3.7 淘汰策略

• 基于数据量（size或者weight）

• 基于过期时间

• 基于引用

4 Caffeine

4.1 异步策略

4.2 ConcurrentHashMap优化特性

4.3 淘汰算法W-LFU

4.4 Caffeine使用

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

Cache<Integer, String> cache = Caffeine.newBuilder().build();

public static AsyncCache<String, User> asyncCache() {
    AsyncCache<String, User> asyncCache = Caffeine.newBuilder()
            .buildAsync();
    asyncCache.get("123", CaffeineDemo::findUserFromDb).join();
    return asyncCache;
}

public static AsyncLoadingCache<String, User> asyncLoadingCache() {
    return Caffeine.newBuilder()
            .initialCapacity(1000) // 指定初始容量
            .maximumSize(10000L) // 指定最大容量
            .expireAfterWrite(30L, TimeUnit.MINUTES) // 指定写入30分钟后过期
            .refreshAfterWrite(1L, TimeUnit.MINUTES) // 指定每隔1分钟刷新下数据内容
            .removalListener((key, value, cause) -> System.out.println(key + "remove: " + cause)) // 监听记录移除事件
            .recordStats() // 开启缓存操作数据统计
            .buildAsync(CaffeineDemo::findUserFromDb);
}
User user = asyncLoadingCache.get("123").join();

5 Spring Cache注解

6 参考

主流缓存框架调研 - Guava/Caffeine/EhCache/JetCache... - EEEEET - 博客园

Spring Cache Spring Cache 是 Spring 提供的一整套的缓存解决方案。虽然它本身并没有提供缓存的实现，但是它提供了一整套的接口和代码规范、配置、注解等，这样它就可以整合各种缓存方案了，比如 Redis、Ehcache，我们也就不用关心操作缓存的细节。 https://do

https://www.cnblogs.com/imyjy/p/15695160.html

Spring Cache注解 · 语雀

1.相关注解spring boot cache 提供了...

https://www.yuque.com/diaomaoshou/tqeueb/crtdzur7fkobdvc8