SpringBoot轻量级缓存区

package com.example.riverside.util.cache; import com.example.riverside.util.Spring.PropertiesLoaderUtils; import com.example.riverside.util.invoke.StreamScheduleInvokeInterface; import com.example.riverside.util.stream.StreamUtils; import lombok.extern.slf4j.Slf4j; import org.springframework.stereotype.Component; import java.util.*; import java.util.concurrent.atomic.AtomicBoolean; /** * 缓存区 * @author tzy * @date 2023年4月25日10:30:21 * @version 2.1 */ @Slf4j @Component public class CacheDistrict { public final static long effectiveTimeDefault = 1000 * 60 * 15; // 15分钟 public final static boolean effectiveTimerDefault = true; private final AtomicBoolean atomicFlag = new AtomicBoolean(true); /** * @TODO cache.district.unification_overdue 配置其缓存有效模式<p> * false: 为每个存在有效期的缓存值加计时器（能有效，准时的释放过期缓存，性能换空间）<p> * true: 由缓存区统一管理有效期（不定期的检查过期缓存并释放，可手动检查过期缓存，空间换性能） * （拓展：1.在GC前释放过期缓存 2.使用一个缓存区计时器） */ private static boolean effectiveTimer; static { try { String effectiveTimerC = PropertiesLoaderUtils.getValue("cache.district.unification_overdue", "application.properties").toString(); effectiveTimer = Boolean.parseBoolean(effectiveTimerC); } catch (Exception e) { effectiveTimer = effectiveTimerDefault; } } private final AutoSortMap<Long, String> autoSortMap = new AutoSortMap<>(Comparator.comparing(AutoSortMap.SortMap::getK)); private final Map<String, CacheIndividual<?>> cacheMap = new WeakHashMap<>(); public int size() { return cacheMap.size(); } public List<String> getAllKey() { List<String> keyList = new ArrayList<>(cacheMap.size()); for(Map.Entry<String, CacheIndividual<?>> entry : cacheMap.entrySet()) { keyList.add(entry.getKey()); } return keyList; } public <T> T getCache(String key) throws Exception { Object cache = getCacheImplement(key); try { return Objects.isNull(cache) ? null : (T) cache; } catch (Exception e) { throw new Exception("类型转换失败!" + e.getMessage()); } } public <T> T getCache(String key, T t) throws Exception { Object cache = getCacheImplement(key); try { t = Objects.isNull(cache) ? null : (T) cache; return t; } catch (Exception e) { throw new Exception("类型转换失败!" + e.getMessage()); } } private Object getCacheImplement(String key){ CacheIndividual<?> cacheIndividual = cacheMap.get(key); if (Objects.isNull(cacheIndividual)) { return null; } Object cache = cacheIndividual.get(); if (Objects.isNull(cache)) { return null; } if (System.currentTimeMillis() > cacheIndividual.getExpireTime()) { return null; } return cache; } public <T> void pushCache(String key, T t, long effectiveTime, String message) { boolean flag = cacheMap.containsKey(key); if (flag) { // 覆盖 CacheIndividual<?> individual = cacheMap.get(key); if (individual != null) individual.lapse(); individual = null; } else { // 新增 } CacheIndividual<T> newIndividual = CacheIndividual.create(t, effectiveTime, message); cacheMap.put(key, newIndividual); this.overdueClear(key, newIndividual); } public <T> boolean pushCache(String key, T t, boolean judge, long effectiveTime, String message) { boolean flag = cacheMap.containsKey(key); if (flag) { if (judge) { // 覆盖 CacheIndividual<?> individual = cacheMap.get(key); if (individual != null) individual.lapse(); individual = null; CacheIndividual<T> newIndividual = CacheIndividual.create(t, effectiveTime, message); cacheMap.put(key, newIndividual); this.overdueClear(key, newIndividual); return true; } else { // 已存在 return false; } } else { // 新增 CacheIndividual<T> newIndividual = CacheIndividual.create(t, effectiveTime, message); cacheMap.put(key, newIndividual); this.overdueClear(key, newIndividual); return true; } } private <T> void overdueClear(String key, CacheIndividual<T> individual) { if (effectiveTimer) { districtOverdueClear(key, individual); } else { itemOverdueClear(key, individual); } } private <T> void districtOverdueClear(String key, CacheIndividual<T> individual) { // 加入自序图前，移除已存在的时间键值 autoSortMap.removeByValue(key); autoSortMap.push(individual.getExpireTime(), key); clearOverdue(); } public void clearOverdue() { if (atomicFlag.compareAndSet(true, false)) { new Thread(() -> { while (true) { if (!autoSortMap.isEmpty()) { AutoSortMap.SortMap<Long, String> sortMap = autoSortMap.first(); if (System.currentTimeMillis() > sortMap.getK()) { String key = sortMap.getV(); CacheIndividual<?> individual = cacheMap.get(key); autoSortMap.pollFirst(); release(key, individual); } else { break; } } else { break; } } atomicFlag.set(true); }).start(); } } private <T> void itemOverdueClear(String key, CacheIndividual<T> individual) { individual.setTimer(new Timer()); individual.getTimer().schedule(new TimerTask() { @Override public void run() { release(key, individual); } }, individual.getEffectiveTime()); } private <T> void release(String key, CacheIndividual<T> individual) { autoSortMap.removeByValue(key); cacheMap.remove(key); if (individual == null) return; log.warn("键：" + key + " 的缓存值已失效"); // 释放资源 individual.set(null); if (individual.getTimer() != null) individual.getTimer().cancel(); individual.setTimer(null); individual = null; } public void flushTime(String key) throws Exception { CacheIndividual<?> individual = cacheMap.get(key); if(individual.getTimer() != null){ individual.getTimer().cancel(); this.overdueClear(key, individual); } else { if (individual.get() == null) { throw new Exception("数据已失效，不能再更新有效时间"); } else { this.overdueClear(key, individual); } } } public void flushTime(String key, long effectiveTime) throws Exception { CacheIndividual<?> individual = cacheMap.get(key); if (individual != null) { individual.setEffectiveTime(effectiveTime); flushTime(key); } } public void neverOverdue(String key) throws Exception { CacheIndi