01、解决方案：本地缓存

一、本地缓存对象

/**
 * @author Lee
 * @version 1.0
 * @description 本地缓存对象
 * @date 2022/7/12 16:03
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class ExpireData {

    private String key; // 键
    private Object value; // 值
    private long expireMillisecond;//过期时长
    private long startTime;//保存时间
    private long endTime;//过期时间

    public ExpireData(String key, Object value) {
        this.key = key;
        this.value = value;
    }

    public ExpireData(String key, Object value, Long expireMillisecond) {
        this.key = key;
        this.value = value;
        this.expireMillisecond = expireMillisecond;
        this.startTime = System.currentTimeMillis();
        this.endTime = startTime + expireMillisecond;
    }
}

二、缓存工具

package com.lee.common.cache.utils;

import com.lee.common.cache.model.ExpireData;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @author Lee
 * @version 1.0
 * @description 本地缓存工具
 * @date 2024/12/13 15:13
 */
public class LoclCacheUtils {

    // 用来存放数据
    private static final Map<String, ExpireData> CACHE_OBJECT_MAP = new ConcurrentHashMap<String, ExpireData>(16);

    /**
     * 普通缓存放入
     *
     * @param key   键
     * @param value 值
     * @return true成功 false失败
     */
    public boolean set(String key, Object value) {
        try {
            ExpireData expireData = new ExpireData(key, value);
            CACHE_OBJECT_MAP.put(key, expireData);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 普通缓存放入并设置时间
     *
     * @param key               键
     * @param value             值
     * @param expireMillisecond 过期时长(毫秒),要大于0,如果小于等于0,将设置无限期
     * @return
     */
    public boolean set(String key, Object value, long expireMillisecond) {
        try {
            if (expireMillisecond > 0) {
                ExpireData expireData = new ExpireData(key, value, expireMillisecond);
                CACHE_OBJECT_MAP.put(key, expireData);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据key获取value
     *
     * @param key 键
     * @return 值
     */
    public Object get(String key) {
        ExpireData expireData = CACHE_OBJECT_MAP.get(key);
        if (expireData == null) {
            return null;
        }
        if (expireData.getExpireMillisecond() == 0) {
            return expireData.getValue();
        }
        long nowTime = System.currentTimeMillis();
        if (nowTime < expireData.getEndTime()) {
            return expireData.getValue();
        } else {
            return null;
        }
    }

    /**
     * 根据key删除
     *
     * @param key 键
     * @return true 成功，false 不成功,key不存在也是true 成功
     */
    public boolean delete(String key) {
        try {
            CACHE_OBJECT_MAP.remove(key);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据prefix 删除key
     *
     * @param prefix
     */
    public void deleteByPrefix(String prefix) {
        for (String key : CACHE_OBJECT_MAP.keySet()) {
            if (key.contains(prefix)) {
                CACHE_OBJECT_MAP.remove(key);
            }
        }
    }

    /**
     * 删除所有
     *
     * @return true 成功，false 不成功
     */
    public boolean flush() {
        try {
            CACHE_OBJECT_MAP.clear();
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 判断key是否存在
     *
     * @param key 键
     * @return true 存在，false不存在
     */
    public boolean hasKey(String key) {
        try {
            return get(key) == null ? false : true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 根据key获取还有多长时间过期
     *
     * @param key 键
     * @return 还有多长时间过期（毫秒）
     */
    public long getExpire(String key) {
        ExpireData expireData = CACHE_OBJECT_MAP.get(key);
        if (null == expireData) {
            return 0;
        }
        // 这个代表没有过期时长
        if (expireData.getExpireMillisecond() == 0) {
            return 999999999999999L;
        }
        long expire = expireData.getEndTime() - System.currentTimeMillis();
        if (expire < 0) {
            return 0;
        } else {
            return expire;
        }
    }

    /**
     * 指定缓存失效时间
     *
     * @param key               键
     * @param expireMillisecond 过期时长(毫秒),要大于0,如果小于等于0,将设置无限期
     * @return true 成功，false 不成功
     */
    public boolean expire(String key, long expireMillisecond) {
        try {
            ExpireData expireData = CACHE_OBJECT_MAP.get(key);
            if (null == expireData) {
                return false;
            }
            if (expireMillisecond > 0) {
                expireData = new ExpireData(key, expireData.getValue(), expireMillisecond);
                CACHE_OBJECT_MAP.put(key, expireData);
            } else {
                set(key, expireData.getValue());
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 获取所有的键
     *
     * @return
     */
    public List<String> getKeys() {
        List<String> list = new ArrayList<String>();
        for (String key : CACHE_OBJECT_MAP.keySet()) {
            if (hasKey(key)) {
                list.add(key);
            }
        }
        return list;
    }

    /**
     * 删除过期的缓存(该方法需要根据实际业务定时调用，不然可能导致内存泄露)
     */
    public void deleteTimeOut() {
        System.out.println(CACHE_OBJECT_MAP.keySet());
        for (String key : CACHE_OBJECT_MAP.keySet()) {
            if (!hasKey(key)) {
                delete(key);
            }
        }
        System.out.println(CACHE_OBJECT_MAP.keySet());
    }

    /**
     * 私有构造方法，为了防止被别的类new出来
     */
    private LoclCacheUtils() {
        // 反射破解单例模式需要添加的代码
        if (SingletonHolder.hashMapCache != null) {
            throw new RuntimeException();
        }
    }

    /**
     * 在成员位置创建该类的对象
     */
    private static class SingletonHolder {
        private static final LoclCacheUtils hashMapCache = new LoclCacheUtils();
    }

    /**
     * 对外提供静态方法获取该对象
     */
    public static LoclCacheUtils getHashMapCache() {
        return SingletonHolder.hashMapCache;
    }

    /**
     * 下面是为了解决序列化反序列化破解单例模式
     */
    private Object readResolve() {
        return SingletonHolder.hashMapCache;
    }
}