前言
之前也用过一些缓存中间件，框架，也想着自己是不是也能用Java写一个出来，于是就有了这个想法，打算在写的过程中同步进行总结
源码：weloe/Java-Distributed-Cache (github.com)
本篇代码：
Java-Distributed-Cache/src/main/java/com/weloe/cache/cachemanager at master · weloe/Java-Distributed-Cache (github.com)
Java-Distributed-Cache/src/test/java/com/weloe/cache/cachemanager at master · weloe/Java-Distributed-Cache (github.com)
上篇：
https://www.cnblogs.com/weloe/p/17050512.html
思路
既然是分布式缓存，那么就一定会有缓存管理方面的问题，既然是要储存的数据，那么就不能让它无限制的存储，就需要设置临界值，这个也是需要缓存淘汰的原因。
而为了对缓存方便管理，比如，我们需要缓存的有多个功能，我们为了方便区分，可能就需要在key前加上功能前缀，这样不仅变得麻烦，同时由于key变大，也会增加内存的压力。
所以我们就需要把缓存分组进行管理，并提供一些方便的对外接口
实现
CacheObj
Java-Distributed-Cache/CacheObj.java at master · weloe/Java-Distributed-Cache (github.com)
在前篇缓存淘汰中，我们确定了我们真正存储数据的是一个k,v结构，因此，我们需要抽象出这里的k,v，k选择String，而v则抽象出一个CacheObj。
需要注意的是，这里的endTime是该缓存到期的时间，一般而言，我们都有为目标缓存设定缓存时间的需求，这也是缓存淘汰策略中的一种。实际存储为byte[]则是为了通用性。
public class CacheObj {
private LocalDateTime endTime;
private Class clazz;
private int byteSize;
// 存储的实际数据
private byte[] data;
public CacheObj() {
}
public CacheObj(LocalDateTime endTime,Class clazz ,int byteSize, byte[] data) {
this.endTime = endTime;
this.clazz = clazz;
this.byteSize = byteSize;
this.data = data;
}
public int getByteSize() {
return byteSize;
}
public byte[] getData() {
return data;
}
public void setEndTime(LocalDateTime endTime) {
this.endTime = endTime;
}
public LocalDateTime getEndTime() {
return endTime;
}
public void setClazz(Class clazz) {
this.clazz = clazz;
}
}
Cache
Java-Distributed-Cache/Cache.java at master · weloe/Java-Distributed-Cache (github.com)
有组管理，也就需要单一的缓存管理
public class Cache {
// 最大字节
private int maxByteSize;
// 目前使用字节
private int normalByteSize;
// 缓存策略
private CacheStrategy<String, CacheObj> cacheStrategy;
Lock readLock;
Lock writeLock;
public Cache(int maxByteSize, CacheStrategy<String, CacheObj> cacheStrategy) {
this.maxByteSize = maxByteSize;
this.normalByteSize = 0;
this.cacheStrategy = cacheStrategy;
readLock = new ReentrantReadWriteLock().readLock();
writeLock = new ReentrantReadWriteLock().writeLock();
}
public CacheObj add(String key, CacheObj cacheObj) {
writeLock.lock();
normalByteSize += cacheObj.getByteSize();
// 缓存上限
while (normalByteSize > maxByteSize) {
// 淘汰缓存
CacheObj outCache = cacheStrategy.outCache();
normalByteSize -= outCache.getByteSize();
}
// 加入缓存
CacheObj v = cacheStrategy.put(key, cacheObj);
writeLock.unlock();
return v;
}
public CacheObj get(String key) {
readLock.lock();
CacheObj v = cacheStrategy.get(key);
// 判断是否过期
if (v != null && v.getEndTime() != null && LocalDateTime.now().isAfter(v.getEndTime())) {
CacheObj obj = cacheStrategy.outCache(key);
return null;
}
readLock.unlock();
return v;
}
public CacheObj remove(String key){
return cacheStrategy.outCache(key);
}
public void clear(){
cacheStrategy.clear();
}
public void setMaxByteSize(int maxByteSize) {
this.maxByteSize = maxByteSize;
}
public int getMaxByteSize() {
return maxByteSize;
}
public int getNormalByteSize() {
return normalByteSize;
}
}
Group
Java-Distributed-Cache/Group.java at master · weloe/Java-Distributed-Cache (github.com)
既然需要组管理，那么就需要抽象出一个Group类型，这里的getter是需要后期自定义的回调函数。
public class Group {
private String name;
private Cache cache;
private Getter getter;
@FunctionalInterface
interface Getter {
byte[] get(String k) throws Exception;
}
put,get
为了方便管理，Group需要提供get，put法
public CacheObj get(String key) {
if ("".equals(key) || key == null) {
throw new RuntimeException("key不能为空");
}
CacheObj cacheObj = cache.get(key);
if (cacheObj != null) {
return cacheObj;
}
return load(key);
}
/**
* 通过Getter回调获取数据
*
* @param key
* @return
*/
private CacheObj load(String key) {
byte[] bytes = null;
try {
bytes = getter.get(key);
} catch (Exception e) {
e.printStackTrace();
return null;
}
if (bytes == null) {
return null;
}
CacheObj cacheObj = BytesUtil.bytes2CacheObj(bytes);
cache.add(key, cacheObj);
return cacheObj;
}
public CacheObj putCacheObj(String key,CacheObj cacheObj){
CacheObj obj = cache.add(key, cacheObj);
return obj;
}
expire
为存储的数据设定存储时间的方法
public CacheObj expire(String key, long num, ChronoUnit timeUnit){
CacheObj cacheObj;
try {
cacheObj = cache.get(key);
cacheObj.setEndTime(LocalDateTime.now().plus(num, timeUnit));
} catch (Exception e) {
return null;
}
return cacheObj;
}
setSize
设置缓存临界值的方法
public boolean setMaxSize(int num){
if(num < cache.getNormalByteSize()){
return false;
}
cache.setMaxByteSize(num);
return true;
}
delete,clear
清除组缓存的方法，从这里也可以看出其方便性，即可以清除单一功能(组)的缓存
public CacheObj delete(String key){
CacheObj obj = cache.remove(key);
return obj;
}
public void clear(){
cache.clear();
}
GroupManager
Java-Distributed-Cache/GroupManager.java at master · weloe/Java-Distributed-Cache (github.com)
既然有Group，就需要管理Group，也就需要相对应的put,get方法
public class GroupManager {
private Map<String, Group> groupMap;
public GroupManager(Map<String, Group> groupMap) {
this.groupMap = groupMap;
}
public Group getGroup(String key) {
Group group = groupMap.get(key);
return group;
}
public Group put(Group group){
return groupMap.put(group.getName(),group);
}
}
测试
CacheTest
Java-Distributed-Cache/CacheTest.java at master · weloe/Java-Distributed-Cache (github.com)
class CacheTest {
Cache cache;
@BeforeEach
void setUp() {
CacheStrategy<String, CacheObj> lruCache = new LRUCache<>(5);
lruCache.setCallback((s1, s2)-> System.out.println("缓存淘汰"));
cache = new Cache(1024*1024,lruCache);
}
@Test
void add() {
String s = "123";
CacheObj cacheObj = new CacheObj(LocalDateTime.MAX, String.class, 512*1024, s.getBytes(StandardCharsets.UTF_8));
cache.add("test", cacheObj);
for (int i = 0; i < 5; i++) {
cache.add("test"+i,cacheObj);
}
}
@Test
void get() {
CacheObj cacheObj = cache.get("123");
Assertions.assertNull(cacheObj);
String s = "123";
cacheObj = new CacheObj(LocalDateTime.MAX,String.class, s.getBytes(StandardCharsets.UTF_8).length, s.getBytes(StandardCharsets.UTF_8));
cache.add("test", cacheObj);
CacheObj test = cache.get("test");
Assertions.assertNotNull(test);
byte[] data = test.getData();
String s1 = BytesUtil.bytes2String(data);
System.out.println(s1);
}
}
GroupTest
Java-Distributed-Cache/GroupTest.java at master · weloe/Java-Distributed-Cache (github.com)
package com.weloe.cache.cachemanager;
import com.weloe.cache.outstrategy.CacheStrategy;
import com.weloe.cache.outstrategy.LRUCache;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.nio.charset.StandardCharsets;
import java.time.temporal.ChronoUnit;
import java.util.concurrent.TimeUnit;
class GroupTest {
Group group;
@BeforeEach
void setUp() {
CacheStrategy<String, CacheObj> lruCache = new LRUCache<>(5);
lruCache.setCallback((s1, s2)-> System.out.println("缓存淘汰"));
group = new Group("group1", new Cache(1024*1024,lruCache), str -> {
System.out.println("group1回调");
return new byte[0];
});
}
@Test
void get() {
group.putCacheObj("1",new CacheObj());
CacheObj cacheObj = group.get("1");
}
@Test
void getName() {
String name = group.getName();
System.out.println(name);
}
@Test
void putCacheObj() {
String x = "132";
group.putCacheObj("cache1",new CacheObj(null,String.class,x.getBytes(StandardCharsets.UTF_8).length,x.getBytes(StandardCharsets.UTF_8)));
}
@Test
void expire() {
String x = "132";
group.putCacheObj("cache1",new CacheObj(null,String.class,x.getBytes(StandardCharsets.UTF_8).length,x.getBytes(StandardCharsets.UTF_8)));
CacheObj cache1 = group.expire("cache1", 2, ChronoUnit.MINUTES);
System.out.println(cache1.getEndTime());
System.out.println(group.get("cache1").getEndTime());
Assertions.assertSame(cache1.getEndTime(),group.get("cache1").getEndTime());
}
}
GroupManagerTest
Java-Distributed-Cache/GroupManagerTest.java at master · weloe/Java-Distributed-Cache (github.com)
package com.weloe.cache.cachemanager;
import com.weloe.cache.outstrategy.LRUCache;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.util.HashMap;
import java.util.concurrent.locks.ReentrantLock;
class GroupManagerTest {
GroupManager groupManager;
@BeforeEach
void setUp() {
Group group1 = new Group("group1",
new Cache(1024*1024, new LRUCache<>(5,(s1, s2)-> System.out.println("group1缓存淘汰"))),
str -> {System.out.println("group1未获取缓存的回调");return new byte[0];}
);
Group group2 = new Group("group2",
new Cache(1024*1024, new LRUCache<>(5,(s1, s2)-> System.out.println("group2缓存淘汰"))),
str -> {System.out.println("group2未获取缓存的回调");return new byte[0];}
);
groupManager = new GroupManager(new HashMap<>(),new ReentrantLock());
groupManager.put(group1);
groupManager.put(group2);
}
@Test
void getGroup() {
System.out.println(groupManager.getGroup(""));
System.out.println(groupManager.getGroup("group1"));
System.out.println(groupManager.getGroup("group2").getName());
}
@Test
void put() {
Group group3 = new Group("group3",
new Cache(1024*1024, new LRUCache<>(5,(s1, s2)-> System.out.println("group3缓存淘汰"))),
str -> {System.out.println("group3未获取缓存的回调");return new byte[0];}
);
groupManager.put(group3);
System.out.println(groupManager.getGroup("group3").getName());
}
}
