登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 业界 ›开窍了！如何为缓存工具类（CacheUtil中的static方法） ...

开窍了！如何为缓存工具类（CacheUtil中的static方法）定义interface（下）

仟仞 3 天前
两个不同策略的缓存工具类

在我们系统的基建包里，有一个基于redis的get/set等基础api封装的 CacheUtil。
CacheUtil 主要有下面2个静态方法：
  1. import java.util.function.Supplier;
  3. public class CacheUtil {
  4.     /**
  5.      * 获取缓存。如果没有，则设置
  6.      */
  7.     public static <T> T getCache(String key, long seconds, Supplier<T> supplier) {
  8.         return getCache(key, seconds, false, supplier);
  9.     }
  11.     /**
  12.      * 获取缓存。如果没有，则设置
  13.      */
  14.     public static <T> T getCache(String key, long seconds, boolean cacheNull, Supplier<T> supplier) {
  15.         Object obj = redisUtil.get(key); // 这里的RedisUtil类封装了 redis 的get/set等基础操作
  16.         if (null == obj) {
  17.             T value = supplier.get();
  18.             ......
  19.             redisUtil.set(key, value, seconds);
  20.             return value;
  21.         } else {
  22.                 ......
  23.             return (T) obj;
  24.         }
  25.     }
  26. }
复制代码
随着后续系统迭代过程中，我增加了一个基于本地缓存框架 hutool-cache 的 LFUCache、TimedCache 来实现的 LocalCacheUtil。
与 CacheUtil 一样的是，LocalCacheUtil 中也主要有下面2个静态方法：
  1. import java.util.function.Supplier;
  3. public class CacheUtil {
  4.     /**
  5.      * 获取缓存。如果没有，则设置
  6.      */
  7.     public static <T> T getCache(String key, long seconds, Supplier<T> supplier) {
  8.         return getCache(key, seconds, false, supplier);
  9.     }
  11.     /**
  12.      * 获取缓存。如果没有，则设置
  13.      */
  14.     public static <T> T getCache(String key, long seconds, boolean allowCacheNullOrEmpty, Supplier<T> supplier) {
  15.         return getCache(timedCache, key, seconds, allowCacheNullOrEmpty, supplier);
  16.     }
  18.     private static <T> T getCache(Cache<String, Object> myCache, String key, Long seconds, boolean allowCacheNullOrEmpty, Supplier<T> supplier) {
  19.         Object cachedValue = myCache.get(key, false);
  20.         if (cachedValue != null) {
  21.             return (T) cachedValue;
  22.         }
  23.         // 允许缓存null值的情况下，如果存在缓存，则直接返回
  24.         if (allowCacheNullOrEmpty && myCache.containsKey(key)) {
  25.             return (T) myCache.get(key, false);
  26.         }
  28.         ......
  29.         T result = supplier.get();
  30.         if (seconds == null) {
  31.             myCache.put(key, result);
  32.         } else {
  33.             myCache.put(key, result, TimeUnit.SECONDS.toMillis(seconds));
  34.         }
  35.         return result;
  36.     }
  37. }
复制代码
如何为两个缓存工具类抽取公共能力？

翻阅 git 提交记录，我发现 CacheUtil 是2020-09 创建的，LocalCacheUtil 是 2022-12 创建的。
虽然两年多过去了，但这其中有一个困扰着我的程序设计问题并没有被遗忘。
这个程序设计问题是， CacheUtil 与 LocalCacheUtil 的职责是相同的，两者都是用来缓存数据。那么，如果能够为两者抽象出来一个缓存数据的 interface，该多香啊！
可是， getCache 方法是 static 静态方法。我们知道，静态方法是无法实现接口的。
我总不能把 getCache 方法改为非静态方法吧？
我不能。倒不是因为需要改所有的调用代码，而是在程序设计原则中，工具类的设计理念通常是为了提供一组相关的实用方法，这些方法不依赖于类的实例状态，而是专注于执行特定的功能。代码实现中，我们通常将工具类的方法定义为 static 或者通过其他方式（如私有化构造函数）防止类在外部被实例化。
那么，我没有办法了！
我曾经在遥远的2017年听过一个架构师讲过类似场景的解决方案，可惜的是，忘却了，脑子里只留下“讲解过”这三个字了。
直到最近，我才想到方案。
知识就是力量，但更重要的是，运用知识的能力

设计模式里的单例模式是良药。是的，饿汉式单例模式（eager singleton pattern）。
以下是使用饿汉式单例模式为 CacheUtil 和 LocalCacheUtil 抽象出接口并进行代码改造的实现。
首先，定义一个缓存接口 CacheService，定义了两个 getCache 方法，这两个方法是缓存工具类的核心操作，不同的缓存实现类需要实现这些方法。
  1. import java.util.function.Supplier;
  3. // 定义缓存服务接口
  4. public interface CacheService {
  5.     /**
  6.      * 获取缓存。如果没有，则设置
  7.      *
  8.      * @param key
  9.      * @param seconds
  10.      * @param supplier 缓存数据提供者
  11.      * @param <T>
  12.      * @return
  13.      */
  14.     <T> T getCache(String key, long seconds, Supplier<T> supplier);
  16.     /**
  17.      * 获取缓存。如果没有，则设置
  18.      *
  19.      * @param key
  20.      * @param seconds
  21.      * @param cacheNull 是否缓存null
  22.      * @param supplier 缓存数据提供者
  23.      * @param <T>
  24.      * @return
  25.      */
  26.     <T> T getCache(String key, long seconds, boolean cacheNull, Supplier<T> supplier);
  27. }
复制代码
接着，将原来的 CacheUtil 类改造为实现 CacheService 接口的单例类，提供基于 Redis 的缓存操作。
  1. // Redis缓存实现类，使用饿汉式单例模式
  2. public class RedisCacheUtil implements CacheService {
  3.     // 饿汉式单例，在类加载时就创建实例
  4.     public static final RedisCacheUtil INSTANCE = new RedisCacheUtil();
  6.     // 私有化构造函数，防止外部实例化
  7.     private RedisCacheUtil() {}
  9.     @Override
  10.     public <T> T getCache(String key, long seconds, Supplier<T> supplier) {
  11.         return getCache(key, seconds, false, supplier);
  12.     }
  14.     @Override
  15.     public <T> T getCache(String key, long seconds, boolean cacheNull, Supplier<T> supplier) {
  16.         ... ...
  17.     }
  18. }
复制代码
然后，将 LocalCacheUtil 类改造为实现 CacheService 接口的单例类，提供基于本地缓存（hutool-cache）的缓存操作。
  1. // 本地缓存实现类，使用饿汉式单例模式
  2. public class LocalCacheUtil implements CacheService {
  3.     // 饿汉式单例，在类加载时就创建实例
  4.     public static final LocalCacheUtil INSTANCE = new LocalCacheUtil();
  6.     // 私有化构造函数，防止外部实例化
  7.     private LocalCacheUtil() {}
  9.     @Override
  10.     public <T> T getCache(String key, long seconds, Supplier<T> supplier) {
  11.         return getCache(key, seconds, false, supplier);
  12.     }
  14.     @Override
  15.     public <T> T getCache(String key, long seconds, boolean allowCacheNullOrEmpty, Supplier<T> supplier) {
  16.         return getCache(timedCache, key, seconds, allowCacheNullOrEmpty, supplier);
  17.     }
  19.     private <T> T getCache(Cache<String, Object> myCache, String key, Long seconds, boolean allowCacheNullOrEmpty, Supplier<T> supplier) {
  20.         ... ...
  21.     }
  22. }
复制代码
通过这种引入饿汉式单例模式的方式，我们成功地为 CacheUtil 和 LocalCacheUtil 两个工具类抽象出了接口。规范了缓存工具类的操作能力。（PS：比较熟悉java8的同学，一眼能看出来，CacheService里，第一个 getCache 可以用 default 来修饰，同样，两个实现类不需要override这个 getCache。这会更香！————当然，这不在本文议题内）

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

使用道具 举报
相关推荐
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
仟仞
3 天前

0

粉丝关注

7

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫