大家好，又见面了，我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE稳定放心使用

工具类定义

package com.demo.utils;
import org.springframework.util.StringUtils;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/** * Description: 缓存工具类 * 1.部分方法未验证，如有问题请自行修改 * 2.其他方法请自行添加 * * @Author: zhx & moon hongxu_1234@163.com * @Date: 2022-04-07 20:54 * @version: V1.0.0 */
public class Cache { 

/** * 屏蔽工具类的无参构造 避免工具类被实例化 */
private Cache(){ 
}
/** * 缓存留存期 30min 1H 24H */
public static final long CACHE_HOLD_TIME_30M = 30 * 60 * 1000L;
public static final long CACHE_HOLD_TIME_1H = 2 * CACHE_HOLD_TIME_30M;
public static final long CACHE_HOLD_TIME_24H = 24 * CACHE_HOLD_TIME_1H;
public static final long CACHE_HOLD_TIME_FOREVER = -1L;
/** * 缓存容量、最少使用容量 */
private static final int CACHE_MAX_CAP = 1000;
private static final int CLEAN_LRU_CAP = 800;
/** * 缓存当前大小 */
private static AtomicInteger CACHE_CURRENT_SIZE = new AtomicInteger(0);
/** * 缓存对象 */
private static final Map<String,Node> CACHE_MAP = new ConcurrentHashMap<>(CACHE_MAX_CAP);
/** * 最少使用记录 */
private static final List<String> LRU_LIST = new LinkedList<>();
/** * 自动清理标志位 */
private static volatile boolean CLEAN_RUN_FLAG = false;
/** * 默认30MIN * @param key * @param val */
public static void put(String key,Object val){ 

put(key,val,CACHE_HOLD_TIME_30M);
}
/** * 添加永久缓存 * @param key * @param val */
public static void putForever(String key,Object val){ 

put(key,val,CACHE_HOLD_TIME_FOREVER);
}
/** * 添加缓存 * @param key * @param val * @param ttlTime */
public static void put(String key,Object val,long ttlTime){ 

if (!StringUtils.hasLength(key) || null == val){ 

return;
}
checkSize();
updateCacheLru(key);
CACHE_MAP.put(key,new Node(val,ttlTime));
}
/** * 获取缓存信息 * @param key * @param clazz * @param <T> * @return */
public static <T> T get(String key,Class<T> clazz){ 

if (!StringUtils.hasLength(key) || !CACHE_MAP.containsKey(key)){ 

return null;
}
updateCacheLru(key);
return (T) CACHE_MAP.get(key).getVal();
}
/** * 更新最近使用位置 * @param key */
private static void updateCacheLru(String key){ 

synchronized (LRU_LIST){ 

LRU_LIST.remove(key);
LRU_LIST.add(0,key);
}
}
/** * 删除,成功则容量-1 * @param key */
private static boolean remove(String key){ 

Node node = CACHE_MAP.remove(key);
if (null!=node){ 

CACHE_CURRENT_SIZE.getAndDecrement();
return true;
}
return false;
}
/** * 检查是否超过容量,先清理过期,在清理最少使用 */
private static void checkSize(){ 

if (CACHE_CURRENT_SIZE.intValue() > CACHE_MAX_CAP){ 

deleteTimeOut();
}
if (CACHE_CURRENT_SIZE.intValue() > CLEAN_LRU_CAP){ 

deleteLru();
}
}
/** * 删除最久未使用,尾部删除 * 永久缓存不会被清除 */
private static void deleteLru(){ 

synchronized (LRU_LIST){ 

while (LRU_LIST.size() > CLEAN_LRU_CAP){ 

int lastIndex = LRU_LIST.size() - 1;
String key = LRU_LIST.get(lastIndex);
if (!CACHE_MAP.get(key).isForever() && remove(key)){ 

LRU_LIST.remove(lastIndex);
}
}
}
}
/** * 删除过期 */
private static void deleteTimeOut(){ 

List<String> del = new LinkedList<>();
for (Map.Entry<String,Node> entry:CACHE_MAP.entrySet()){ 

if (entry.getValue().isExpired()){ 

del.add(entry.getKey());
}
}
for (String k:del){ 

remove(k);
}
}
/** * 缓存是否已存在,过期则删除返回False * @param key * @return */
public static boolean contains(String key){ 

if (CACHE_MAP.containsKey(key)){ 

if (!CACHE_MAP.get(key).isExpired()){ 

return true;
}
if (remove(key)){ 

return false;
}
return true;
}
return false;
}
/** * 清空缓存 */
public static void clear(){ 

CACHE_MAP.clear();
CACHE_CURRENT_SIZE.set(0);
LRU_LIST.clear();
}
/** * 重置自动清理标志 * @param flag */
public static void setCleanRunFlag(boolean flag){ 

CLEAN_RUN_FLAG = flag;
}
/** * 自动清理过期缓存 */
private static void startAutoClean(){ 

if (!CLEAN_RUN_FLAG){ 

setCleanRunFlag(true);
ScheduledExecutorService scheduledExecutor = new ScheduledThreadPoolExecutor(1);
scheduledExecutor.scheduleAtFixedRate(()->{ 

try { 

Cache.setCleanRunFlag(true);
while (CLEAN_RUN_FLAG){ 

Cache.deleteTimeOut();
}
} catch (Exception e) { 

e.printStackTrace();
}
},10,Cache.CACHE_HOLD_TIME_1H, TimeUnit.SECONDS);
}
}
/** * 缓存对象类 */
public static class Node{ 

/** * 缓存值 */
private Object val;
/** * 过期时间 */
private long ttlTime;
public Node(Object val,long ttlTime){ 

this.val = val;
if (ttlTime<0){ 

this.ttlTime = ttlTime;
}else{ 

this.ttlTime = System.currentTimeMillis() + ttlTime;
}
}
public Object getVal(){ 

return this.val;
}
public boolean isExpired(){ 

if (this.ttlTime<0){ 

return false;
}
return System.currentTimeMillis() > this.ttlTime;
}
public boolean isForever(){ 

if (this.ttlTime<0){ 

return true;
}
return false;
}
}
}