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

分类:java 2021-09-18T10:52:28    167人阅读   

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

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

支付宝打赏 微信打赏

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

服务器费用不足...

创意布局企业网络服务CSS模板

CSS 3D盒子打开动画特效

网站顶部导航带下拉的Navigation

餐厅美食在线订餐HTML5站点模板

沙滩保卫小游戏js源码

5套WebApp模板管理后台界面

绿色农产品果蔬购物商店HTML主题

绿色环保种植农场网站Html5模板

互联网机构和SaaS服务网页模板

优雅而现代的企业和商业html模板

多用途的Alert弹出窗口Js插件

HTML5/Canvas太空射击类小游戏源码

21个着陆页HTML5和CSS3模板

炫酷网状变形动画js特效

整个页面滚动切换Js插件

五彩纸屑掉落动画的例子

拖拽实现流程图Drawflow.js插件

牛奶和饼干css卡通图画

CSS3主页个人简历网页模板

公司事件会议发布会网站模板

服务器费用不足...
 工具推荐 更多»