关于java:再见Guava再见Ehcache

30次阅读

共计 10183 个字符，预计需要花费 26 分钟才能阅读完成。

一、Caffeine 介绍

1、缓存介绍

缓存 (Cache) 在代码世界中无处不在。从底层的 CPU 多级缓存，到客户端的页面缓存，处处都存在着缓存的身影。缓存从实质上来说，是一种空间换工夫的伎俩，通过对数据进行肯定的空间安顿，使得下次进行数据拜访时起到减速的成果。

就 Java 而言，其罕用的缓存解决方案有很多，例如数据库缓存框架 EhCache，分布式缓存 Memcached 等，这些缓存计划实际上都是为了晋升吞吐效率，防止长久层压力过大。

对于常见缓存类型而言，能够分为本地缓存以及分布式缓存两种，Caffeine 就是一种优良的本地缓存，而 Redis 能够用来做分布式缓存

2、Caffeine 介绍

Caffeine 官网：

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

Caffeine 是基于 Java 1.8 的高性能本地缓存库，由 Guava 改良而来，而且在 Spring5 开始的默认缓存实现就将 Caffeine 代替原来的 Google Guava，官网阐明指出，其缓存命中率曾经靠近最优值。实际上 Caffeine 这样的本地缓存和 ConcurrentMap 很像，即反对并发，并且反对 O(1)工夫复杂度的数据存取。二者的次要区别在于：

  • ConcurrentMap 将存储所有存入的数据，直到你显式将其移除；
  • Caffeine 将通过给定的配置，主动移除“不罕用”的数据，以放弃内存的正当占用。

因而，一种更好的了解形式是：Cache 是一种带有存储和移除策略的 Map。

二、Caffeine 根底

应用 Caffeine，须要在工程中引入如下依赖

<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
    <!--https://mvnrepository.com/artifact/com.github.ben-manes.caffeine/caffeinez 找最新版 -->
    <version>3.0.5</version>
</dependency>

举荐一个开源收费的 Spring Boot 实战我的项目：

https://github.com/javastacks/spring-boot-best-practice

1、缓存加载策略

1.1 Cache 手动创立

最一般的一种缓存，无需指定加载形式，须要手动调用 put() 进行加载。须要留神的是 put() 办法对于已存在的 key 将进行笼罩，这点和 Map 的体现是统一的。在获取缓存值时，如果想要在缓存值不存在时，原子地将值写入缓存，则能够调用 get(key, k -> value) 办法，该办法将防止写入竞争。调用 invalidate() 办法，将手动移除缓存。

在多线程状况下，当应用 get(key, k -> value) 时，如果有另一个线程同时调用本办法进行竞争，则后一线程会被阻塞，直到前一线程更新缓存实现；而若另一线程调用 getIfPresent() 办法，则会立刻返回 null，不会被阻塞。

Cache<Object, Object> cache = Caffeine.newBuilder()
          // 初始数量
          .initialCapacity(10)
          // 最大条数
          .maximumSize(10)
          //expireAfterWrite 和 expireAfterAccess 同时存在时，以 expireAfterWrite 为准
          // 最初一次写操作后通过指定工夫过期
          .expireAfterWrite(1, TimeUnit.SECONDS)
          // 最初一次读或写操作后通过指定工夫过期
          .expireAfterAccess(1, TimeUnit.SECONDS)
          // 监听缓存被移除
          .removalListener((key, val, removalCause) -> {})
          // 记录命中
          .recordStats()
          .build();

  cache.put("1","张三");
  // 张三
  System.out.println(cache.getIfPresent("1"));
  // 存储的是默认值
  System.out.println(cache.get("2",o -> "默认值"));
1.2 Loading Cache 主动创立

LoadingCache 是一种主动加载的缓存。其和一般缓存不同的中央在于，当缓存不存在 / 缓存已过期时，若调用 get() 办法，则会主动调用 CacheLoader.load() 办法加载最新值。调用 getAll() 办法将遍历所有的 key 调用 get()，除非实现了 CacheLoader.loadAll() 办法。应用 LoadingCache 时，须要指定 CacheLoader，并实现其中的 load() 办法供缓存缺失时主动加载。

在多线程状况下，当两个线程同时调用get()，则后一线程将被阻塞，直至前一线程更新缓存实现。

LoadingCache<String, String> loadingCache = Caffeine.newBuilder()
        // 创立缓存或者最近一次更新缓存后通过指定工夫距离，刷新缓存；refreshAfterWrite 仅反对 LoadingCache
        .refreshAfterWrite(10, TimeUnit.SECONDS)
        .expireAfterWrite(10, TimeUnit.SECONDS)
        .expireAfterAccess(10, TimeUnit.SECONDS)
        .maximumSize(10)
        // 依据 key 查询数据库外面的值，这里是个 lamba 表达式
        .build(key -> new Date().toString());
1.3 Async Cache 异步获取

AsyncCache 是 Cache 的一个变体，其响应后果均为 CompletableFuture，通过这种形式，AsyncCache 对异步编程模式进行了适配。默认状况下，缓存计算应用ForkJoinPool.commonPool() 作为线程池，如果想要指定线程池，则能够笼罩并实现 Caffeine.executor(Executor) 办法。synchronous()提供了阻塞直到异步缓存生成结束的能力，它将以 Cache 进行返回。

在多线程状况下，当两个线程同时调用 get(key, k -> value)，则会返回同一个CompletableFuture 对象。因为返回后果自身不进行阻塞，能够依据业务设计自行抉择阻塞期待或者非阻塞。

AsyncLoadingCache<String, String> asyncLoadingCache = Caffeine.newBuilder()
        // 创立缓存或者最近一次更新缓存后通过指定工夫距离刷新缓存；仅反对 LoadingCache
        .refreshAfterWrite(1, TimeUnit.SECONDS)
        .expireAfterWrite(1, TimeUnit.SECONDS)
        .expireAfterAccess(1, TimeUnit.SECONDS)
        .maximumSize(10)
        // 依据 key 查询数据库外面的值
        .buildAsync(key -> {Thread.sleep(1000);
            return new Date().toString();
        });

// 异步缓存返回的是 CompletableFuture
CompletableFuture<String> future = asyncLoadingCache.get("1");
future.thenAccept(System.out::println);

2、驱赶策略

驱赶策略在创立缓存的时候进行指定。罕用的有基于容量的驱赶和基于工夫的驱赶。

基于容量的驱赶须要指定缓存容量的最大值，当缓存容量达到最大时，Caffeine 将应用 LRU 策略对缓存进行淘汰；基于工夫的驱赶策略如字面意思，能够设置在最初拜访 / 写入一个缓存通过指定工夫后，主动进行淘汰。

驱赶策略能够组合应用，任意驱赶策略失效后，该缓存条目即被驱赶。

  • LRU 最近起码应用，淘汰最长工夫没有被应用的页面。
  • LFU 最不常常应用，淘汰一段时间内应用次数起码的页面
  • FIFO 先进先出

Caffeine 有 4 种缓存淘汰设置

  • 大小（LFU 算法进行淘汰）
  • 权重（大小与权重 只能二选一）
  • 工夫
  • 援用（不罕用，本文不介绍）
@Slf4j
public class CacheTest {
    /**
     * 缓存大小淘汰
     */
    @Test
    public void maximumSizeTest() throws InterruptedException {Cache<Integer, Integer> cache = Caffeine.newBuilder()
                // 超过 10 个后会应用 W -TinyLFU 算法进行淘汰
                .maximumSize(10)
                .evictionListener((key, val, removalCause) -> {log.info("淘汰缓存：key:{} val:{}", key, val);
                })
                .build();

        for (int i = 1; i < 20; i++) {cache.put(i, i);
        }
        Thread.sleep(500);// 缓存淘汰是异步的

        // 打印还没被淘汰的缓存
        System.out.println(cache.asMap());
    }

    /**
     * 权重淘汰
     */
    @Test
    public void maximumWeightTest() throws InterruptedException {Cache<Integer, Integer> cache = Caffeine.newBuilder()
                // 限度总权重，若所有缓存的权重加起来 > 总权重就会淘汰权重小的缓存
                .maximumWeight(100)
                .weigher((Weigher<Integer, Integer>) (key, value) -> key)
                .evictionListener((key, val, removalCause) -> {log.info("淘汰缓存：key:{} val:{}", key, val);
                })
                .build();

        // 总权重其实是 = 所有缓存的权重加起来
        int maximumWeight = 0;
        for (int i = 1; i < 20; i++) {cache.put(i, i);
            maximumWeight += i;
        }
        System.out.println("总权重 =" + maximumWeight);
        Thread.sleep(500);// 缓存淘汰是异步的

        // 打印还没被淘汰的缓存
        System.out.println(cache.asMap());
    }


    /**
     * 拜访后到期（每次拜访都会重置工夫，也就是说如果始终被拜访就不会被淘汰）*/
    @Test
    public void expireAfterAccessTest() throws InterruptedException {Cache<Integer, Integer> cache = Caffeine.newBuilder()
                .expireAfterAccess(1, TimeUnit.SECONDS)
                // 能够指定调度程序来及时删除过期缓存项，而不是期待 Caffeine 触发定期维护
                // 若不设置 scheduler，则缓存会在下一次调用 get 的时候才会被动删除
                .scheduler(Scheduler.systemScheduler())
                .evictionListener((key, val, removalCause) -> {log.info("淘汰缓存：key:{} val:{}", key, val);

                })
                .build();
        cache.put(1, 2);
        System.out.println(cache.getIfPresent(1));
        Thread.sleep(3000);
        System.out.println(cache.getIfPresent(1));//null
    }

    /**
     * 写入后到期
     */
    @Test
    public void expireAfterWriteTest() throws InterruptedException {Cache<Integer, Integer> cache = Caffeine.newBuilder()
                .expireAfterWrite(1, TimeUnit.SECONDS)
                // 能够指定调度程序来及时删除过期缓存项，而不是期待 Caffeine 触发定期维护
                // 若不设置 scheduler，则缓存会在下一次调用 get 的时候才会被动删除
                .scheduler(Scheduler.systemScheduler())
                .evictionListener((key, val, removalCause) -> {log.info("淘汰缓存：key:{} val:{}", key, val);
                })
                .build();
        cache.put(1, 2);
        Thread.sleep(3000);
        System.out.println(cache.getIfPresent(1));//null
    }
}

3、刷新机制

refreshAfterWrite()示意 x 秒后主动刷新缓存的策略能够配合淘汰策略应用，留神的是刷新机制只反对 LoadingCache 和 AsyncLoadingCache

private static int NUM = 0;

@Test
public void refreshAfterWriteTest() throws InterruptedException {LoadingCache<Integer, Integer> cache = Caffeine.newBuilder()
            .refreshAfterWrite(1, TimeUnit.SECONDS)
            // 模仿获取数据，每次获取就自增 1
            .build(integer -> ++NUM);

    // 获取 ID= 1 的值，因为缓存里还没有，所以会主动放入缓存
    System.out.println(cache.get(1));// 1

    // 提早 2 秒后，实践上主动刷新缓存后取到的值是 2
    // 但其实不是，值还是 1，因为 refreshAfterWrite 并不是设置了 n 秒后从新获取就会主动刷新
    // 而是 x 秒后 && 第二次调用 getIfPresent 的时候才会被动刷新
    Thread.sleep(2000);
    System.out.println(cache.getIfPresent(1));// 1

    // 此时才会刷新缓存，而第一次拿到的还是旧值
    System.out.println(cache.getIfPresent(1));// 2
}

4、统计

LoadingCache<String, String> cache = Caffeine.newBuilder()
        // 创立缓存或者最近一次更新缓存后通过指定工夫距离，刷新缓存；refreshAfterWrite 仅反对 LoadingCache
        .refreshAfterWrite(1, TimeUnit.SECONDS)
        .expireAfterWrite(1, TimeUnit.SECONDS)
        .expireAfterAccess(1, TimeUnit.SECONDS)
        .maximumSize(10)
        // 开启记录缓存命中率等信息
        .recordStats()
        // 依据 key 查询数据库外面的值
        .build(key -> {Thread.sleep(1000);
            return new Date().toString();
        });


cache.put("1", "shawn");
cache.get("1");

/*
 * hitCount : 命中的次数
 * missCount: 未命中次数
 * requestCount: 申请次数
 * hitRate: 命中率
 * missRate: 失落率
 * loadSuccessCount: 胜利加载新值的次数
 * loadExceptionCount: 失败加载新值的次数
 * totalLoadCount: 总条数
 * loadExceptionRate: 失败加载新值的比率
 * totalLoadTime: 全副加载工夫
 * evictionCount: 失落的条数
 */
System.out.println(cache.stats());

5、总结

上述一些策略在创立时都能够进行自由组合，个别状况下有两种办法

  • 设置 maxSize、refreshAfterWrite，不设置 expireAfterWrite/expireAfterAccess，设置 expireAfterWrite 当缓存过期时会同步加锁获取缓存，所以设置 expireAfterWrite 时性能较好，然而某些时候会取旧数据, 适宜容许取到旧数据的场景
  • 设置 maxSize、expireAfterWrite/expireAfterAccess，不设置 refreshAfterWrite 数据一致性好，不会获取到旧数据，然而性能没那么好（比照起来），适宜获取数据时不耗时的场景

三、SpringBoot 整合 Caffeine

举荐一个开源收费的 Spring Boot 实战我的项目：

https://github.com/javastacks/spring-boot-best-practice

1、@Cacheable 相干注解

1.1 相干依赖

如果要应用 @Cacheable 注解，须要引入相干依赖，并在任一配置类文件上增加 @EnableCaching 注解

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
1.2 罕用注解
  • @Cacheable：示意该办法反对缓存。当调用被注解的办法时，如果对应的键曾经存在缓存，则不再执行办法体，而从缓存中间接返回。当办法返回 null 时，将不进行缓存操作。
  • @CachePut：示意执行该办法后，其值将作为最新后果更新到缓存中，每次都会执行该办法。
  • @CacheEvict：示意执行该办法后，将触发缓存革除操作。
  • @Caching：用于组合前三个注解，例如：
@Caching(cacheable = @Cacheable("CacheConstants.GET_USER"),
         evict = {@CacheEvict("CacheConstants.GET_DYNAMIC",allEntries = true)}
public User find(Integer id) {return null;}
1.3 罕用注解属性
  • cacheNames/value：缓存组件的名字，即 cacheManager 中缓存的名称。
  • key：缓存数据时应用的 key。默认应用办法参数值，也能够应用 SpEL 表达式进行编写。
  • keyGenerator：和 key 二选一应用。
  • cacheManager：指定应用的缓存管理器。
  • condition：在办法执行开始前查看，在合乎 condition 的状况下，进行缓存
  • unless：在办法执行实现后查看，在合乎 unless 的状况下，不进行缓存
  • sync：是否应用同步模式。若应用同步模式，在多个线程同时对一个 key 进行 load 时，其余线程将被阻塞。
1.4 缓存同步模式

sync 开启或敞开，在 Cache 和 LoadingCache 中的体现是不统一的：

  • Cache 中，sync 示意是否须要所有线程同步期待
  • LoadingCache 中，sync 示意在读取不存在 / 已驱赶的 key 时，是否执行被注解办法

2、实战

2.1 引入依赖
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>

<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
</dependency>
2.2 缓存常量 CacheConstants

创立缓存常量类，把公共的常量提取一层，复用，这里也能够通过配置文件加载这些数据，例如 @ConfigurationProperties 和@Value

public class CacheConstants {
    /**
     * 默认过期工夫（配置类中我应用的工夫单位是秒，所以这里如 3*60 为 3 分钟）*/
    public static final int DEFAULT_EXPIRES = 3 * 60;
    public static final int EXPIRES_5_MIN = 5 * 60;
    public static final int EXPIRES_10_MIN = 10 * 60;

    public static final String GET_USER = "GET:USER";
    public static final String GET_DYNAMIC = "GET:DYNAMIC";

}
2.3 缓存配置类 CacheConfig
@Configuration
@EnableCaching
public class CacheConfig {
    /**
     * Caffeine 配置阐明：* initialCapacity=[integer]: 初始的缓存空间大小
     * maximumSize=[long]: 缓存的最大条数
     * maximumWeight=[long]: 缓存的最大权重
     * expireAfterAccess=[duration]: 最初一次写入或拜访后通过固定工夫过期
     * expireAfterWrite=[duration]: 最初一次写入后通过固定工夫过期
     * refreshAfterWrite=[duration]: 创立缓存或者最近一次更新缓存后通过固定的工夫距离，刷新缓存
     * weakKeys: 关上 key 的弱援用
     * weakValues：关上 value 的弱援用
     * softValues：关上 value 的软援用
     * recordStats：开发统计性能
     * 留神：* expireAfterWrite 和 expireAfterAccess 共事存在时，以 expireAfterWrite 为准。* maximumSize 和 maximumWeight 不能够同时应用
     * weakValues 和 softValues 不能够同时应用
     */
    @Bean
    public CacheManager cacheManager() {SimpleCacheManager cacheManager = new SimpleCacheManager();
        List<CaffeineCache> list = new ArrayList<>();
        // 循环增加枚举类中自定义的缓存，能够自定义
        for (CacheEnum cacheEnum : CacheEnum.values()) {list.add(new CaffeineCache(cacheEnum.getName(),
                    Caffeine.newBuilder()
                            .initialCapacity(50)
                            .maximumSize(1000)
                            .expireAfterAccess(cacheEnum.getExpires(), TimeUnit.SECONDS)
                            .build()));
        }
        cacheManager.setCaches(list);
        return cacheManager;
    }
}
2.4 调用缓存

这里要留神的是 Cache 和 @Transactional 一样也应用了代理，类内调用将生效

/**
 * value：缓存 key 的前缀。* key：缓存 key 的后缀。* sync：设置如果缓存过期是不是只放一个申请去申请数据库，其余申请阻塞，默认是 false（依据集体需要）。* unless：不缓存空值, 这里不应用，会报错
 * 查问用户信息类
 * 如果须要加自定义字符串，须要用单引号
 * 如果查问为 null，也会被缓存
 */
@Cacheable(value = CacheConstants.GET_USER,key = "'user'+#userId",sync = true)
@CacheEvict
public UserEntity getUserByUserId(Integer userId){UserEntity userEntity = userMapper.findById(userId);
    System.out.println("查问了数据库");
    return userEntity;
}

版权申明：本文为 CSDN 博主「魅 Lemon」的原创文章，遵循 CC 4.0 BY-SA 版权协定，转载请附上原文出处链接及本申明。原文链接：https://blog.csdn.net/lemon_TT/article/details/122905113

近期热文举荐：

1.1,000+ 道 Java 面试题及答案整顿(2022 最新版)

2. 劲爆！Java 协程要来了。。。

3.Spring Boot 2.x 教程，太全了！

4. 别再写满屏的爆爆爆炸类了，试试装璜器模式，这才是优雅的形式！！

5.《Java 开发手册（嵩山版）》最新公布，速速下载！

感觉不错，别忘了顺手点赞 + 转发哦！

正文完
java
发表至： java
2023-07-10
 0
关于java:JZ039平衡二叉树
Rust错误处理
关于java:引不要再使用null判空了
关于java:Serverless-初体验快速开发与部署一个Hello-WorldJava版