package com.walker.cache;
|
|
import com.fasterxml.jackson.core.JsonProcessingException;
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
import com.walker.cache.util.KeyUtils;
|
import com.walker.infrastructure.core.ApplicationBeanDestroied;
|
import com.walker.infrastructure.core.ApplicationBeanInitialized;
|
import com.walker.infrastructure.utils.Assert;
|
import com.walker.infrastructure.utils.ObjectStreamUtils;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
|
import java.util.ArrayList;
|
import java.util.Collection;
|
import java.util.HashSet;
|
import java.util.Iterator;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Set;
|
import java.util.concurrent.ConcurrentHashMap;
|
|
/**
|
* <p/>抽象的内存缓存对象，以纯内存方式管理缓存的基类
|
* @author MikeShi
|
*
|
*/
|
public abstract class AbstractMemoryCache implements Cache, ApplicationBeanInitialized, ApplicationBeanDestroied {
|
|
/**
|
*
|
*/
|
private static final long serialVersionUID = 2575070748765281205L;
|
|
// protected final transient Log logger = LogFactory.getLog(this.getClass());
|
protected final transient Logger logger = LoggerFactory.getLogger(this.getClass());
|
|
ConcurrentHashMap<String, Cachable> cacheMap = new ConcurrentHashMap<String, Cachable>(CacheConfig.INIT_CACHEMAP_SIZE);
|
|
private String cacheName;
|
|
public long expiredTime = 0;
|
|
private boolean writeOnDiskAfterShutdown = false;
|
|
private CacheOperateListener cacheOperateListener = null;
|
|
private boolean hasCacheListener = false;
|
|
public void setCacheOperateListener(CacheOperateListener cacheOperateListener) {
|
if(cacheOperateListener != null){
|
hasCacheListener = true;
|
}
|
this.cacheOperateListener = cacheOperateListener;
|
}
|
|
public AbstractMemoryCache(){}
|
|
public String getCacheName() {
|
return cacheName;
|
}
|
|
public void setCacheName(String name) {
|
this.cacheName = name;
|
}
|
|
public long getExpiredTime() {
|
return expiredTime;
|
}
|
|
public void setExpiredTime(int seconds) {
|
this.expiredTime = seconds*1000;
|
}
|
|
public Iterator<Cachable> getIterator(){
|
synchronized (cacheMap) {
|
return cacheMap.values().iterator();
|
}
|
}
|
|
@SuppressWarnings("unchecked")
|
public void startup() {
|
logger.debug("........ execute startup in AbstractMemoryCache! cacheName = " + cacheName);
|
Assert.isTrue(cacheName != null && !cacheName.equals(""));
|
if(writeOnDiskAfterShutdown){
|
Object obj = ObjectStreamUtils.readObjectFromFile(CacheConfig.WRITE_TEMP_CACHEFILE + cacheName);
|
if(obj != null){
|
logger.info("load cache data from disk! cache name: " + cacheName);
|
cacheMap = (ConcurrentHashMap<String, Cachable>)obj;
|
}
|
}
|
}
|
public void shutdown() {
|
logger.debug("........ execute shutdown in AbstractMemoryCache! cacheName = " + cacheName);
|
if(writeOnDiskAfterShutdown && !cacheMap.isEmpty()){
|
ObjectStreamUtils.writeObjectToFile(CacheConfig.WRITE_TEMP_CACHEFILE + cacheName, cacheMap);
|
}
|
cacheMap.clear();
|
cacheMap = null;
|
cacheName = null;
|
}
|
|
public boolean isWriteOnDiskAfterShutdown() {
|
return writeOnDiskAfterShutdown;
|
}
|
|
public void setWriteOnDiskAfterShutdown(boolean boo) {
|
writeOnDiskAfterShutdown = boo;
|
}
|
|
public String toString(){
|
StringBuilder sb = new StringBuilder();
|
sb.append("[cacheName=");
|
sb.append(cacheName);
|
sb.append(", expiredTime=");
|
sb.append(expiredTime);
|
sb.append(", cacheSize=");
|
sb.append(cacheMap.size());
|
sb.append(", data=");
|
sb.append(cacheMap);
|
sb.append("]");
|
return sb.toString();
|
}
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
// cache data operations
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
/**
|
* 根据key，从缓存取出一个用户数据
|
*/
|
public Object get(String key) {
|
// public T get(String key) {
|
// logger.debug("----------" + cacheMap.get(key).isExpired(System.currentTimeMillis(), expiredTime));
|
Cachable d = cacheMap.get(key);
|
if(d != null){
|
return d.getValue();
|
}
|
return null;
|
}
|
|
/**
|
* 放入缓存一条新数据
|
*/
|
public void put(String key, Object data) {
|
Assert.notNull(key);
|
Assert.notNull(data);
|
|
// synchronized (cacheMap) {
|
Cachable cacheData = new CacheData();
|
cacheData.setKey(key);
|
cacheData.setValue(data);
|
|
cacheMap.put(key, cacheData);
|
if(hasCacheListener){
|
cacheOperateListener.onPut(data);
|
}
|
// }
|
}
|
|
/**
|
* 放入缓存数据有时间有效期
|
* @param key
|
* @param data
|
* @param expiredSeconds 过期秒数
|
* @date 2022-11-06
|
*/
|
public void put(String key, Object data, long expiredSeconds){
|
throw new UnsupportedOperationException("该方法由<code>RedisCache</code>或者业务自定义CacheProvider实现。");
|
}
|
|
/**
|
* 删除一条缓存数据
|
*/
|
public Object remove(String key) {
|
// synchronized (cacheMap){
|
Cachable c = cacheMap.remove(key);
|
if(c != null){
|
Object v = c.getValue();
|
if(hasCacheListener){
|
cacheOperateListener.onRemove(v);
|
}
|
return v;
|
}
|
return null;
|
// }
|
}
|
|
/**
|
* 替换key相同的缓存数据为data
|
*/
|
public void replace(String key, Object data) {
|
// synchronized (cacheMap) {
|
Cachable cacheData = cacheMap.get(key);
|
if(cacheData != null){
|
cacheData.setValue(data);
|
cacheData.setTimeStamp(System.currentTimeMillis());
|
cacheData.hit();
|
}
|
// }
|
}
|
|
/**
|
* 根据数据key，更新缓存数据时间戳
|
*/
|
public void updateCacheDataTimeStamp(String key) {
|
Cachable c = cacheMap.get(key);
|
if(c != null){
|
c.setTimeStamp(System.currentTimeMillis());
|
c.hit();
|
} else
|
logger.warn("updateCacheDataTimeStamp error: cache data not found! key = " + key);
|
}
|
|
/**
|
* 删除给定的列表数据，从缓存对象中
|
*/
|
public void remove(List<String> keys) {
|
Assert.notNull(keys);
|
synchronized (cacheMap){
|
for(String key : keys){
|
cacheMap.remove(key);
|
}
|
}
|
}
|
|
/**
|
* 清除缓存数据
|
*/
|
public void clear(){
|
cacheMap.clear();
|
if(hasCacheListener){
|
cacheOperateListener.onClear();
|
}
|
}
|
|
public Object get(String key, Class<?> clazz) {
|
throw new UnsupportedOperationException();
|
}
|
|
public List<String> getIterator(Class<?> clazz) {
|
throw new UnsupportedOperationException();
|
}
|
|
public long getPersistentSize() {
|
return 0;
|
}
|
|
@Override
|
public long size(){
|
return cacheMap.size();
|
}
|
|
/**
|
* 返回给定限制的缓存数据集合
|
* @param maxSize 限制的最大数量
|
* @return
|
*/
|
@Override
|
public Collection<Object> queryListLimit(int maxSize){
|
if(maxSize < 0 || maxSize >=Integer.MAX_VALUE){
|
return null;
|
}
|
|
if(cacheMap.size() <= maxSize){
|
ObjectMapper mapper = new ObjectMapper();
|
// 当缓存数量小于给定限制，显示全部
|
List<Object> resultList = new ArrayList<>(cacheMap.size());
|
String json = null;
|
for(Cachable c : cacheMap.values()){
|
try {
|
json = mapper.writeValueAsString(c.getValue());
|
resultList.add(json);
|
} catch (JsonProcessingException e) {
|
throw new RuntimeException(e);
|
}
|
// resultList.add(JSONObject.toJSON(c.getValue()).toString());
|
}
|
return resultList;
|
|
} else {
|
//
|
throw new IllegalArgumentException("缓存数量大于给定的限制值，不能显示数据，数量过大");
|
}
|
}
|
|
@Override
|
public Set<Object> getKeys() {
|
Set<Object> keyList = new HashSet<>();
|
for(Iterator<String> it = this.cacheMap.keySet().iterator(); it.hasNext();){
|
keyList.add(it.next());
|
}
|
return keyList;
|
}
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
//~ 2023-06-13 操作集合，但目前没有使用，感觉删除整个集合还比较麻烦。
|
//~ 2023-06-14 确定使用该对象，并测试结果。
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
private ConcurrentHashMap<String, List> listMap = new ConcurrentHashMap<>(CacheConfig.INIT_CACHEMAP_SIZE);
|
|
@Override
|
public void putList(String key, List<Object> data, long expiredSeconds){
|
this.listMap.put(this.acquireListKey(key), data);
|
}
|
|
@Override
|
public void putListAppend(String key, Object data){
|
List list = this.listMap.get(this.acquireListKey(key));
|
if(list == null){
|
list = new ArrayList();
|
this.listMap.put(this.acquireListKey(key), list);
|
}
|
list.add(data);
|
}
|
|
@Override
|
public List<Object> getList(String key, long start, long end, Class<?> clazz){
|
return this.listMap.get(this.acquireListKey(key));
|
}
|
|
@Override
|
public void removeList(String key, Object value){
|
List list = this.listMap.get(this.acquireListKey(key));
|
if(list != null){
|
Object obj = null;
|
for(Iterator<Object> it = list.iterator(); it.hasNext();){
|
obj = it.next();
|
if(value.equals(obj)){
|
it.remove();
|
}
|
}
|
}
|
}
|
|
/**
|
* 根据Key 删除对应整个集合。
|
* @param key
|
* @date 2023-08-03
|
*/
|
@Override
|
public void removeList(String key){
|
this.listMap.remove(this.acquireListKey(key));
|
}
|
|
@Override
|
public long getListSize(String key){
|
List list = this.listMap.get(this.acquireListKey(key));
|
if(list == null){
|
return 0;
|
}
|
return list.size();
|
}
|
|
private String acquireListKey(String key){
|
return KeyUtils.acquireListKey(this.getCacheName(), key);
|
}
|
|
public void print(){
|
int size = 2;
|
if(this.listMap.size() > 10){
|
logger.info("内存中已经超过10条数据，总量 = " + this.listMap.size() + " 个集合，只打印前10条");
|
size = 10;
|
}
|
int count = 0;
|
for(Map.Entry<String, List> entry : this.listMap.entrySet()){
|
if(count > size){
|
break;
|
}
|
logger.info("key = {}, value = {}", entry.getKey(), entry.getValue());
|
count ++;
|
}
|
}
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
}
|
