联系人列表为空，请先登录

转载 

EhCache 和 Guava 的使用及特点分析以及简单实现个轮子demo代码

分类:java    655人阅读    IT小君  2021-09-18 10:52

1. EhCache 和 Guava 的使用及特点分析

EhCache 是目前比较流行的开源缓存框架，是用纯 Java 语言实现的简单、快速的 Cache 组件。EhCache 支持内存缓存和磁盘缓存，支持 LRU（Least Recently Used，最近很少使用）、LFU（Least Frequently Used，最近不常被使用）和 FIFO（First In First Out，先进先出）等多种淘汰算法，并且支持分布式的缓存系统。

EhCache 最初是独立的本地缓存框架组件，在后期的发展中（从 1.2 版）开始支持分布式缓存，分布式缓存主要支持 RMI、JGroups、EhCache Server 等方式。

LRU 和 LFU 的区别

LRU 算法有一个缺点，比如说很久没有使用的一个键值，如果最近被访问了一次，那么即使它是使用次数最少的缓存，它也不会被淘汰；而 LFU 算法解决了偶尔被访问一次之后，数据就不会被淘汰的问题，它是根据总访问次数来淘汰数据的，其核心思想是“如果数据过去被访问多次，那么将来它被访问次数也会比较多”。因此 LFU 可以理解为比 LRU 更加合理的淘汰算法。

EhCache 基础使用

首先，需要在项目中添加 EhCache 框架，如果为 Maven 项目，则需要在 pom.xml 中添加如下配置：

 
复制代码
  1. <!-- https://mvnrepository.com/artifact/org.ehcache/ehcache -->
  2. <dependency>
  3.     <groupId>org.ehcache</groupId>
  4.     <artifactId>ehcache</artifactId>
  5.     <version>3.8.1</version>
  6. </dependency>

无配置参数的 EhCache 3.x 使用代码如下：

 
复制代码
  1. import org.ehcache.Cache;
  2. import org.ehcache.CacheManager;
  3. import org.ehcache.config.builders.CacheConfigurationBuilder;
  4. import org.ehcache.config.builders.CacheManagerBuilder;
  5. import org.ehcache.config.builders.ResourcePoolsBuilder;
  6.  
  7. public class EhCacheExample {
  8.     public static void main(String[] args) {
  9.         // 创建缓存管理器
  10.         CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder().build();
  11.         // 初始化 EhCache
  12.         cacheManager.init();
  13.         // 创建缓存（存储器）
  14.         Cache<String, String> myCache = cacheManager.createCache("MYCACHE",
  15.                 CacheConfigurationBuilder.newCacheConfigurationBuilder(
  16.                         String.class, String.class,
  17.                         ResourcePoolsBuilder.heap(10))); // 设置缓存的最大容量
  18.         // 设置缓存
  19.         myCache.put("key", "Hello,Java.");
  20.         // 读取缓存
  21.         String value = myCache.get("key");
  22.         // 输出缓存
  23.         System.out.println(value);
  24.         // 关闭缓存
  25.         cacheManager.close();
  26.     }
  27. }

其中：

  • CacheManager：是缓存管理器，可以通过单例或者多例的方式创建，也是 Ehcache 的入口类；

  • Cache：每个 CacheManager 可以管理多个 Cache，每个 Cache 可以采用 hash 的方式存储多个元素。

  •  

EhCache 的特点是，它使用起来比较简单，并且本身的 jar 包不是不大，简单的配置之后就可以正常使用了。EhCache 的使用比较灵活，它支持多种缓存策略的配置，它同时支持内存和磁盘缓存两种方式，在 EhCache 1.2 之后也开始支持分布式缓存了。

Guava Cache 是 Google 开源的 Guava 里的一个子功能，它是一个内存型的本地缓存实现方案，提供了线程安全的缓存操作机制。

Guava Cache 的架构设计灵感来源于 ConcurrentHashMap，它使用了多个 segments 方式的细粒度锁，在保证线程安全的同时，支持了高并发的使用场景。Guava Cache 类似于 Map 集合的方式对键值对进行操作，只不过多了过期淘汰等处理逻辑。

在使用 Guava Cache 之前，我们需要先在 pom.xml 中添加 Guava 框架，配置如下：

 
复制代码
  1. <!-- https://mvnrepository.com/artifact/com.google.guava/guava -->
  2. <dependency>
  3.     <groupId>com.google.guava</groupId>
  4.     <artifactId>guava</artifactId>
  5.     <version>28.2-jre</version>
  6. </dependency>

Guava Cache 的创建有两种方式，一种是 LoadingCache，另一种是 Callable，代码示例如下：

 
复制代码
  1. import com.google.common.cache.*;
  2.  
  3. import java.util.concurrent.Callable;
  4. import java.util.concurrent.ExecutionException;
  5. import java.util.concurrent.TimeUnit;
  6.  
  7. public class GuavaExample {
  8.     public static void main(String[] args) throws ExecutionException {
  9.         // 创建方式一：LoadingCache
  10.         LoadingCache<String, String> loadCache = CacheBuilder.newBuilder()
  11.                 // 并发级别设置为 5，是指可以同时写缓存的线程数
  12.                 .concurrencyLevel(5)
  13.                 // 设置 8 秒钟过期
  14.                 .expireAfterWrite(8, TimeUnit.SECONDS)
  15.                 //设置缓存容器的初始容量为 10
  16.                 .initialCapacity(10)
  17.                 // 设置缓存最大容量为 100，超过之后就会按照 LRU 算法移除缓存项
  18.                 .maximumSize(100)
  19.                 // 设置要统计缓存的命中率
  20.                 .recordStats()
  21.                 // 设置缓存的移除通知
  22.                 .removalListener(new RemovalListener<Object, Object>() {
  23.                     public void onRemoval(RemovalNotification<Object, Object> notification) {
  24.                         System.out.println(notification.getKey() + " was removed, cause is " + notification.getCause());
  25.                     }
  26.                 })
  27.                 // 指定 CacheLoader，缓存不存在时，可自动加载缓存
  28.                 .build(
  29.                         new CacheLoader<String, String>() {
  30.                             @Override
  31.                             public String load(String key) throws Exception {
  32.                                 // 自动加载缓存的业务
  33.                                 return "cache-value:" + key;
  34.                             }
  35.                         }
  36.                 );
  37.         // 设置缓存
  38.         loadCache.put("c1", "Hello, c1.");
  39.         // 查询缓存
  40.         String val = loadCache.get("c1");
  41.         System.out.println(val);
  42.         // 查询不存在的缓存
  43.         String noval = loadCache.get("noval");
  44.         System.out.println(noval);
  45.  
  46.         // 创建方式二：Callable
  47.         Cache<String, String> cache = CacheBuilder.newBuilder()
  48.                 .maximumSize(2) // 设置缓存最大长度
  49.                 .build();
  50.         // 设置缓存
  51.         cache.put("k1", "Hello, k1.");
  52.         // 查询缓存
  53.         String value = cache.get("k1", new Callable<String>() {
  54.             @Override
  55.             public String call() {
  56.                 // 缓存不存在时，执行
  57.                 return "nil";
  58.             }
  59.         });
  60.         // 输出缓存值
  61.         System.out.println(value);
  62.         // 查询缓存
  63.         String nokey = cache.get("nokey", new Callable<String>() {
  64.             @Override
  65.             public String call() {
  66.                 // 缓存不存在时，执行
  67.                 return "nil";
  68.             }
  69.         });
  70.         // 输出缓存值
  71.         System.out.println(nokey);
  72.     }
  73. }

以上程序的执行结果为：

 
复制代码
  1. Hello, c1.
  2. cache-value:noval
  3. Hello, k1.
  4. nil

可以看出 Guava Cache 使用了编程式的 build 生成器进行创建和管理，让使用者可以更加灵活地操纵代码，并且 Guava Cache 提供了灵活多样的个性化配置，以适应各种使用场景。

2. 手动实现一个缓存系统

上面我们讲了通过 EhCache 和 Guava 实现缓存的方式，接下来我们来看看自己如何自定义一个缓存系统，当然这里说的是自己手动实现一个本地缓存。

要自定义一个缓存，首先要考虑的是数据类型，我们可以使用 Map 集合中的 HashMap、Hashtable 或 ConcurrentHashMap 来实现，非并发情况下我们可以使用 HashMap，并发情况下可以使用 Hashtable 或 ConcurrentHashMap，由于 ConcurrentHashMap 的性能比 Hashtable 的高，因此在高并发环境下我们可以倾向于选择 ConcurrentHashMap，不过它们对元素的操作都是类似的。

选定了数据类型之后，我们还需要考虑缓存过期和缓存淘汰等问题，在这里我们可以借鉴 Redis 对待过期键的处理策略。

目前比较常见的过期策略有以下三种：

  • 定时删除

  • 惰性删除

  • 定期删除

定时删除是指在设置键值的过期时间时，创建一个定时事件，当到达过期时间后，事件处理器会执行删除过期键的操作。它的优点是可以及时的释放内存空间，缺点是需要开启多个延迟执行事件来处理清除任务，这样就会造成大量任务事件堆积，占用了很多系统资源。

惰性删除不会主动删除过期键，而是在每次请求时才会判断此值是否过期，如果过期则删除键值，否则就返回正常值。它的优点是只会占用少量的系统资源，缺点是清除不够及时，会造成一定的空间浪费。

定期删除是指每隔一段时间检查一次数据库，随机删除一些过期键值。

Redis 使用的是定期删除和惰性删除这两种策略，我们本课时也会参照这两种策略。

先来说一下自定义缓存的实现思路，首先需要定义一个存放缓存值的实体类，这个类里包含了缓存的相关信息，比如缓存的 key 和 value，缓存的存入时间、最后使用时间和命中次数（预留字段，用于支持 LFU 缓存淘汰），再使用 ConcurrentHashMap 保存缓存的 key 和 value 对象（缓存值的实体类），然后再新增一个缓存操作的工具类，用于添加和删除缓存，最后再缓存启动时，开启一个无限循环的线程用于检测并删除过期的缓存，实现代码如下。

首先，定义一个缓存值实体类，代码如下：

 
复制代码
  1. import lombok.Getter;
  2. import lombok.Setter;
  3.  
  4. /**
  5. * 缓存实体类
  6. */
  7. @Getter
  8. @Setter
  9. public class MyCache implements Comparable<MyCache> {
  10. // 缓存键
  11. private Object key;
  12. // 缓存值
  13. private Object value;
  14. // 最后访问时间
  15. private long lastTime;
  16. // 创建时间
  17. private long writeTime;
  18. // 存活时间
  19. private long expireTime;
  20. // 命中次数
  21. private Integer hitCount;
  22.  
  23. @Override
  24. public int compareTo(MyCache o) {
  25. return hitCount.compareTo(o.hitCount);
  26. }
  27. }

然后定义一个全局缓存对象，代码如下：

 
复制代码
  1. import java.util.concurrent.ConcurrentHashMap;
  2. import java.util.concurrent.ConcurrentMap;
  3.  
  4. /**
  5.  * Cache 全局类
  6.  */
  7. public class CacheGlobal {
  8.     // 全局缓存对象
  9.     public static ConcurrentMap<String, MyCache> concurrentMap = new ConcurrentHashMap<>();
  10. }

定义过期缓存检测类的代码如下：

 
复制代码
  1. import java.util.concurrent.TimeUnit;
  2.  
  3. /**
  4.  * 过期缓存检测线程
  5.  */
  6. public class ExpireThread implements Runnable {
  7.     @Override
  8.     public void run() {
  9.         while (true) {
  10.             try {
  11.                 // 每十秒检测一次
  12.                 TimeUnit.SECONDS.sleep(10);
  13.                 // 缓存检测和清除的方法
  14.                 expireCache();
  15.             } catch (Exception e) {
  16.                 e.printStackTrace();
  17.             }
  18.         }
  19.     }
  20.  
  21.     /**
  22.      * 缓存检测和清除的方法
  23.      */
  24.     private void expireCache() {
  25.         System.out.println("检测缓存是否过期缓存");
  26.         for (String key : CacheGlobal.concurrentMap.keySet()) {
  27.             MyCache cache = CacheGlobal.concurrentMap.get(key);
  28.             // 当前时间 - 写入时间
  29.             long timoutTime = System.currentTimeMillis() - cache.getWriteTime();
  30.             if (cache.getExpireTime() > timoutTime) {
  31.                 // 没过期
  32.                 continue;
  33.             }
  34.             // 清除过期缓存
  35.             CacheGlobal.concurrentMap.remove(key);
  36.         }
  37.     }
  38. }

接着，我们要新增一个缓存操作的工具类，用于查询和存入缓存，实现代码如下：

 
复制代码
  1. import org.apache.commons.lang3.StringUtils;
  2.  
  3. import java.util.concurrent.TimeUnit;
  4.  
  5. /**
  6. * 缓存操作工具类
  7. */
  8. public class CacheUtils {
  9.  
  10. /**
  11. * 添加缓存
  12. * @param key
  13. * @param value
  14. * @param expire
  15. */
  16. public void put(String key, Object value, long expire) {
  17. // 非空判断，借助 commons-lang3
  18. if (StringUtils.isBlank(key)) return;
  19. // 当缓存存在时，更新缓存
  20. if (CacheGlobal.concurrentMap.containsKey(key)) {
  21. MyCache cache = CacheGlobal.concurrentMap.get(key);
  22. cache.setHitCount(cache.getHitCount() + 1);
  23. cache.setWriteTime(System.currentTimeMillis());
  24. cache.setLastTime(System.currentTimeMillis());
  25. cache.setExpireTime(expire);
  26. cache.setValue(value);
  27. return;
  28. }
  29. // 创建缓存
  30. MyCache cache = new MyCache();
  31. cache.setKey(key);
  32. cache.setValue(value);
  33. cache.setWriteTime(System.currentTimeMillis());
  34. cache.setLastTime(System.currentTimeMillis());
  35. cache.setHitCount(1);
  36. cache.setExpireTime(expire);
  37. CacheGlobal.concurrentMap.put(key, cache);
  38. }
  39.  
  40. /**
  41. * 获取缓存
  42. * @param key
  43. * @return
  44. */
  45. public Object get(String key) {
  46. // 非空判断
  47. if (StringUtils.isBlank(key)) return null;
  48. // 字典中不存在
  49. if (CacheGlobal.concurrentMap.isEmpty()) return null;
  50. if (!CacheGlobal.concurrentMap.containsKey(key)) return null;
  51. MyCache cache = CacheGlobal.concurrentMap.get(key);
  52. if (cache == null) return null;
  53. // 惰性删除，判断缓存是否过期
  54. long timoutTime = System.currentTimeMillis() - cache.getWriteTime();
  55. // 缓存过期
  56. if (cache.getExpireTime() <= timoutTime) {
  57. // 清除过期缓存
  58. CacheGlobal.concurrentMap.remove(key);
  59. return null;
  60. }
  61. cache.setHitCount(cache.getHitCount() + 1);
  62. cache.setLastTime(System.currentTimeMillis());
  63. return cache.getValue();
  64. }
  65. }

最后是调用缓存的测试代码：

 
复制代码
  1. public class MyCacheTest {
  2.     public static void main(String[] args) {
  3.         CacheUtils cache = new CacheUtils();
  4.         // 存入缓存
  5.         cache.put("key", "老王", 10);
  6.         // 查询缓存
  7.         String val = (String) cache.get("key");
  8.         System.out.println(val);
  9.         // 查询不存在的缓存
  10.         String noval = (String) cache.get("noval");
  11.         System.out.println(noval);
  12.     }
  13. }

以上程序的执行结果如下：

 
复制代码
  1. 老王
  2. null

到目前为止，自定义缓存系统就已经实现完了。

赏 支付宝打赏 微信打赏

如果文章对你有帮助，欢迎点击上方按钮打赏作者

 博文推荐 更多»
赛博活佛cloudflare workers 免费部署动态网站原理解析及实战
微信免签约收款方案及源码（android+java）
揭秘最为知名的黑客工具之一： Netcat
知乎热议：为什么多数程序员都不做个人独立开发？
SpringBoot 项目 Jar 包加密，防止反编译！
Talkatone美国免费虚拟电话注册及使用指南（保号+下载+接收短信+获取号码+替代）
Midjourney开源代理工具
 最热实例源代码 更多»
  android.view.animation.AnticipateOvershootInterpolator#android.view.WindowManager实例Demo源码 4378阅
  android.view.View实例Demo源码 3957阅
  org.springframework.web.bind.annotation.RequestBody实例Demo源码 3944阅
  org.springframework.web.bind.annotation.GetMapping实例Demo源码 3910阅
  org.springframework.boot.context.embedded.tomcat.TomcatEmbeddedServletContainerFactory实例Demo源码 3720阅
  org.springframework.web.bind.annotation.PostMapping实例Demo源码 3647阅
 工具推荐 更多»
淘宝商品上架1比1（1:1）图片批量一键调整工具，好用哭了
TTF字体抽取压缩、JSON格式化、qrcode 二维码生成解码工具windows桌面版
视频&图片 水印 免费除
frp0.53.2下载备份
免费录屏工具
自动必应刷搜索积分插件 auto get Microsoft Rewards chrome/edge plugin
chromedriver win64 116.0.5845.96 (r1160321) 下载
notepad++ 下载 备份 npp.8.4.6.Installer.x64版本
Git-2.38.1-64-bit 下载备份
java17 jdk-17_windows-x64_bin 下载备份
java JDK1.8 x64 下载
notepad++ 二维码生成插件nppqrcode
站酷小薇LOGO体 ttf
spacedesk，将你的移动设备（手机或者平板）转变成你电脑的第二个显示器的软件(apk、win10 客户端下载)
idisplay，将你的移动设备（手机或者平板）转变成你电脑的第二个显示器的软件
sqlmap：开源的sql 自动注入、渗透 测试工具
中文字体songti.ttf
IA图片助手(ImageAssistant)，轻松下载网页所有图片
微软雅黑体(msyh.ttf)字体
tinymce_5.8.2 编译版本和开发版本 包含汉化脚本
LICEcap GIF 视屏截图、屏幕录制工具
ScreenToGif gif 录屏工具 v2.32.1 绿色免安装中文版
截图录制编辑GIF工具GifCam免安装中文绿色版和英文最新版
GC日志可视化分析工具GCViewer1.36
JAVA内存分析工具（Memory Analyzer Tool，MAT）独立安装版
VisualVM Java 程序性能分析、虚拟机GC分析工具-visualvm_207.zip
JClassLib开源的字节码阅读和编辑器器-jclasslib_win64_5_8.exe
Git-2.31.1 windows 下载
SoapUI-5.3.0 windows免安装版
QuickRedis Redis 可视化管理工具