前言
我们在 从零手写 cache 框架(一)实现固定大小的缓存 中已经初步实现了我们的 cache。
我们在 从零手写 cache 框架(一)实现过期特性 中实现了 key 的过期特性。
本节,让我们来一起学习一下如何实现类似 redis 中的 rdb 的持久化模式。
持久化的目的
我们存储的信息都是直接放在内存中的,如果断电或者应用重启,那么内容就全部丢失了。
有时候我们希望这些信息重启之后还在,就像 redis 重启一样。
load 加载
说明
在实现持久化之前,我们来看一下一个简单的需求:
如何在缓存启动的时候,指定初始化加载的信息。
实现思路
这个也不难,我们在 cache 初始化的时候,直接设置对应的信息即可。
api
为了便于后期拓展,定义 ICacheLoad 接口。
public interface ICacheLoad<K, V> {
/**
* 加载缓存信息
* @param cache 缓存
* @since 0.0.7
*/
void load(final ICache<K,V> cache);
}
自定义初始化策略
我们在初始化的时候,放入 2 个固定的信息。
public class MyCacheLoad implements ICacheLoad<String,String> {
@Override
public void load(ICache<String, String> cache) {
cache.put("1", "1");
cache.put("2", "2");
}
}
测试
只需要在缓存初始化的时候,指定对应的加载实现类即可。
ICache<String, String> cache = CacheBs.<String,String>newInstance()
.load(new MyCacheLoad())
.build();
Assert.assertEquals(2, cache.size());
持久化
说明
上面先介绍初始化加载,其实已经完成了 cache 持久化的一半。
我们要做的另一件事,就是将 cache 的内容持久化到文件或者数据库,便于初始化的时候加载。
接口定义
为了便于灵活替换,我们定义一个持久化的接口。
public interface ICachePersist<K, V> {
/**
* 持久化缓存信息
* @param cache 缓存
* @since 0.0.7
*/
void persist(final ICache<K, V> cache);
}
简单实现
我们实现一个最简单的基于 json 的持久化,当然后期可以添加类似于 AOF 的持久化模式。
public class CachePersistDbJson<K,V> implements ICachePersist<K,V> {
/**
* 数据库路径
* @since 0.0.8
*/
private final String dbPath;
public CachePersistDbJson(String dbPath) {
this.dbPath = dbPath;
}
/**
* 持久化
* key长度 key+value
* 第一个空格,获取 key 的长度,然后截取
* @param cache 缓存
*/
@Override
public void persist(ICache<K, V> cache) {
Set<Map.Entry<K,V>> entrySet = cache.entrySet();
// 创建文件
FileUtil.createFile(dbPath);
// 清空文件
FileUtil.truncate(dbPath);
for(Map.Entry<K,V> entry : entrySet) {
K key = entry.getKey();
Long expireTime = cache.expire().expireTime(key);
PersistEntry<K,V> persistEntry = new PersistEntry<>();
persistEntry.setKey(key);
persistEntry.setValue(entry.getValue());
persistEntry.setExpire(expireTime);
String line = JSON.toJSONString(persistEntry);
FileUtil.write(dbPath, line, StandardOpenOption.APPEND);
}
}
}
定时执行
上面定义好了一种持久化的策略,但是没有提供对应的触发方式。
我们就采用对用户透明的设计方式:定时执行。
public class InnerCachePersist<K,V> {
private static final Log log = LogFactory.getLog(InnerCachePersist.class);
/**
* 缓存信息
* @since 0.0.8
*/
private final ICache<K,V> cache;
/**
* 缓存持久化策略
* @since 0.0.8
*/
private final ICachePersist<K,V> persist;
/**
* 线程执行类
* @since 0.0.3
*/
private static final ScheduledExecutorService EXECUTOR_SERVICE = Executors.newSingleThreadScheduledExecutor();
public InnerCachePersist(ICache<K, V> cache, ICachePersist<K, V> persist) {
this.cache = cache;
this.persist = persist;
// 初始化
this.init();
}
/**
* 初始化
* @since 0.0.8
*/
private void init() {
EXECUTOR_SERVICE.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
try {
log.info("开始持久化缓存信息");
persist.persist(cache);
log.info("完成持久化缓存信息");
} catch (Exception exception) {
log.error("文件持久化异常", exception);
}
}
}, 0, 10, TimeUnit.MINUTES);
}
}
定时执行的时间间隔为 10min。
测试
我们只需要在创建 cache 时,指定我们的持久化策略即可。
ICache<String, String> cache = CacheBs.<String,String>newInstance()
.load(new MyCacheLoad())
.persist(CachePersists.<String, String>dbJson("1.rdb"))
.build();
Assert.assertEquals(2, cache.size());
TimeUnit.SECONDS.sleep(5);
为了确保文件持久化完成,我们沉睡了一会儿。
文件效果
- 1.rdb
生成的文件内容如下:
{"key":"2","value":"2"}
{"key":"1","value":"1"}
对应的缓存加载
我们只需要实现以下对应的加载即可,解析文件,然后初始化 cache。
/**
* 加载策略-文件路径
* @author binbin.hou
* @since 0.0.8
*/
public class CacheLoadDbJson<K,V> implements ICacheLoad<K,V> {
private static final Log log = LogFactory.getLog(CacheLoadDbJson.class);
/**
* 文件路径
* @since 0.0.8
*/
private final String dbPath;
public CacheLoadDbJson(String dbPath) {
this.dbPath = dbPath;
}
@Override
public void load(ICache<K, V> cache) {
List<String> lines = FileUtil.readAllLines(dbPath);
log.info("[load] 开始处理 path: {}", dbPath);
if(CollectionUtil.isEmpty(lines)) {
log.info("[load] path: {} 文件内容为空,直接返回", dbPath);
return;
}
for(String line : lines) {
if(StringUtil.isEmpty(line)) {
continue;
}
// 执行
// 简单的类型还行,复杂的这种反序列化会失败
PersistEntry<K,V> entry = JSON.parseObject(line, PersistEntry.class);
K key = entry.getKey();
V value = entry.getValue();
Long expire = entry.getExpire();
cache.put(key, value);
if(ObjectUtil.isNotNull(expire)) {
cache.expireAt(key, expire);
}
}
//nothing...
}
}
然后在初始化时使用即可。
小结
到这里,我们一个类似于 redis rdb 的持久化就简单模拟完成了。
但是对于 rdb 这里还有需要可优化点,比如 rdb 文件的压缩、格式的定义、CRC 校验等等。
redis 考虑到性能问题,还有 AOF 的持久化模式,二者相辅相成,才能达到企业级别的缓存效果。
我们后续将陆续引入这些特性。
对你有帮助的话,欢迎点赞评论收藏关注一波~
你的鼓励,是我最大的动力~
**粗体** _斜体_ [链接](http://example.com) `代码` - 列表 > 引用
。你还可以使用@
来通知其他用户。